Mercurial > pub > bltoolkit

comparison UnitTests/Linq/IdlTest.cs @ 0:f990fcb411a9

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Копия текущей версии из github
author cin
date Thu, 27 Mar 2014 21:46:09 +0400
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:f990fcb411a9
1 using System;
2 using System.Collections.Generic;
3 using System.Linq;
4 using System.Linq.Expressions;
5 using BLToolkit.Data.DataProvider;
6 using BLToolkit.Data.Linq;
7 using BLToolkit.Data.Sql.SqlProvider;
8 using BLToolkit.DataAccess;
9 using BLToolkit.Mapping;
10 using Data.Linq.Model;
11 using NUnit.Framework;
12
13 namespace Data.Linq
14 {
15 [TestFixture]
16 public partial class IdlTest : TestBase
17 {
18 class IdlProvidersAttribute : IncludeDataContextsAttribute
19 {
20 public IdlProvidersAttribute()
21 : base(ProviderName.SQLite, ProviderName.MySql, "Sql2005", "Sql2008")
22 {
23 }
24 }
25
26 private void ForProvider(string providerName, Action<ITestDataContext> func)
27 {
28 ForEachProvider(Providers.Select(p => p.Name).Except(new[] { providerName }).ToArray(), func);
29 }
30
31 private void ForMySqlProvider(Action<ITestDataContext> func)
32 {
33 ForEachProvider(Providers.Select(p => p.Name).Except(new[] { ProviderName.MySql }).ToArray(), func);
34 }
35
36 #region PersonWithId
37
38 public interface IHasID
39 {
40 int ID { get; set; }
41 }
42
43 [TableName(Name = "Person")]
44 public class PersonWithId : IHasID
45 {
46 public PersonWithId()
47 {
48 }
49
50 public PersonWithId(int id)
51 {
52 ID = id;
53 }
54
55 public PersonWithId(int id, string firstName)
56 {
57 ID = id;
58 FirstName = firstName;
59 }
60
61 [Identity, PrimaryKey]
62 [SequenceName("Firebird", "PersonID")]
63 [MapField("PersonID")]
64 public int ID { get; set; }
65 public string FirstName { get; set; }
66 public string LastName;
67 [Nullable] public string MiddleName;
68 public Gender Gender;
69
70 [MapIgnore]
71 public string Name
72 {
73 get { return FirstName + " " + LastName; }
74 }
75
76 public override bool Equals(object obj)
77 {
78 return Equals(obj as PersonWithId);
79 }
80
81 public bool Equals(PersonWithId other)
82 {
83 if (ReferenceEquals(null, other)) return false;
84 if (ReferenceEquals(this, other)) return true;
85 return
86 other.ID == ID &&
87 Equals(other.LastName, LastName) &&
88 Equals(other.MiddleName, MiddleName) &&
89 other.Gender == Gender &&
90 Equals(other.FirstName, FirstName);
91 }
92
93 public override int GetHashCode()
94 {
95 unchecked
96 {
97 var result = ID;
98 result = (result * 397) ^ (LastName != null ? LastName.GetHashCode() : 0);
99 result = (result * 397) ^ (MiddleName != null ? MiddleName.GetHashCode() : 0);
100 result = (result * 397) ^ Gender.GetHashCode();
101 result = (result * 397) ^ (FirstName != null ? FirstName.GetHashCode() : 0);
102 return result;
103 }
104 }
105 }
106
107 #endregion
108
109 #region ObjectId
110
111 public interface IHasObjectId2
112 {
113 ObjectId Id { get; set; }
114 }
115
116 public interface IHasObjectId1
117 {
118 ObjectId Id { get; set; }
119 }
120
121 public struct ObjectId
122 {
123 public ObjectId(int value)
124 {
125 m_value = value;
126 }
127
128 private int m_value;
129
130 public int Value
131 {
132 get { return m_value; }
133 set { m_value = value; }
134 }
135
136 public static implicit operator int(ObjectId val)
137 {
138 return val.m_value;
139 }
140 }
141
142 public class WithObjectIdBase : IHasObjectId1
143 {
144 public ObjectId Id { get; set; }
145 }
146
147 public class PersonWithObjectId : WithObjectIdBase, IHasObjectId2
148 {
149 public string FistName { get; set; }
150 }
151
152 public struct NullableObjectId
153 {
154 public NullableObjectId(int? value)
155 {
156 m_value = value;
157 }
158
159 private int? m_value;
160
161 public int? Value
162 {
163 get { return m_value; }
164 set { m_value = value; }
165 }
166
167 public static implicit operator int?(NullableObjectId val)
168 {
169 return val.m_value;
170 }
171 }
172
173 #endregion
174
175 [Test]
176 public void TestComplexExpression([IdlProviders] string providerName)
177 {
178 // failed with BLToolkit.Data.Linq.LinqException : 'new StationObjectId() {Value = ConvertNullable(child.ChildID)}'
179 // cannot be converted to SQL.
180 ForProvider(
181 providerName,
182 db =>
183 {
184 var source = from child in db.GrandChild
185 select
186 new
187 {
188 NullableId = new NullableObjectId { Value = child.ChildID }
189 };
190
191 var query = from e in source where e.NullableId == 1 select e;
192
193 var result = query.ToArray();
194 Assert.That(result, Is.Not.Null);
195 });
196 }
197
198 [Test]
199 public void TestJoin([IdlProviders] string providerName)
200 {
201 // failed with System.ArgumentOutOfRangeException : Index was out of range. Must be non-negative and less than
202 // the size of the collection.
203 // Parameter name: index
204 ForProvider(
205 providerName,
206 db =>
207 {
208 var source = from p1 in db.Person
209 join p2 in db.Person on p1.ID equals p2.ID
210 select
211 new { ID1 = new ObjectId { Value = p1.ID }, FirstName2 = p2.FirstName, };
212
213 var query = from p1 in source select p1.ID1.Value;
214
215 var result = query.ToArray();
216 Assert.That(result, Is.Not.Null);
217 });
218 }
219
220 [Test]
221 public void TestNullableExpression([IdlProviders] string providerName)
222 {
223 // failed with System.NullReferenceException : Object reference not set to an instance of an object.
224 ForProvider(
225 providerName,
226 db =>
227 {
228 var source = from obj in db.Person select new { Id = obj.ID, };
229
230 // fails for bool?, double?, int32?, int64?, string
231 // works for byte?, int16?, DateTime?
232 double? @p1 = null;
233
234 var r = from c in source where @p1 != null select c;
235
236 Assert.That(r.ToArray(), Is.Not.Null);
237 });
238 }
239
240 [Test]
241 public void TestLookupWithInterfaceProperty([IdlProviders] string providerName)
242 {
243 ForProvider(
244 providerName,
245 db =>
246 {
247 var r = GetById<PersonWithId>(db, 1).SingleOrDefault();
248 Assert.That(r, Is.Not.Null);
249 });
250 }
251
252 #region ObjectExt
253
254 public abstract class ObjectWithId
255 {
256 public ObjectId Id;
257 }
258
259 public class ParentEx : ObjectWithId
260 {
261 public int? Value1;
262 }
263
264 #endregion
265
266 [Test]
267 public void TestForObjectExt([IdlProviders] string providerName)
268 {
269 ForProvider(
270 providerName,
271 db =>
272 {
273 var r = from p in db.Parent
274 select new ParentEx
275 {
276 Id = new ObjectId { Value = p.ParentID },
277 Value1 = p.Value1,
278 };
279 Assert.That(r.ToArray(), Is.Not.Null);
280 });
281 }
282
283 private void getData(ITestDataContext db, IEnumerable<int?> d, IEnumerable<int?> compareWith)
284 {
285 var r1 = db.GrandChild
286 .Where(x => d.Contains(x.ParentID))
287 .GroupBy(x => x.ChildID, x => x.GrandChildID)
288 .ToList();
289 foreach (var group in r1)
290 {
291 Assert.That(compareWith.Any(x => group.Contains(x)), Is.True);
292 }
293 }
294
295 [Test]
296 public void TestForGroupBy([IdlProviders] string providerName)
297 {
298 ForProvider(
299 providerName,
300 db =>
301 {
302 /* no error in first call */
303 getData(db, new List<int?> { 2 }, new List<int?> { 211, 212, 221, 222 });
304
305 /* error in second and more calls */
306 /*
307 * GROUP BY select clause is correct
308 SELECT x.ChildID FROM GrandChild x WHERE x.ParentID IN (3) GROUP BY x.ChildID
309
310 * But next SELECT clause contains "x.ParentID IN (2)" instead "x.ParentID IN (3)"
311 -- DECLARE ?p1 Int32
312 -- SET ?p1 = 31
313 SELECT x.GrandChildID FROM GrandChild x WHERE x.ParentID IN (2) AND x.ChildID = ?p1
314 */
315 getData(db, new List<int?> { 3 }, new List<int?> { 311, 312, 313, 321, 333 });
316 });
317 }
318
319 [Test]
320 public void TestLinqMax([IdlProviders] string providerName)
321 {
322 ForProvider(
323 providerName,
324 db =>
325 {
326 Assert.That(db.Patient.Where(x => x.PersonID < 0).Select(x => (int?)x.PersonID).Max(), Is.Null);
327 Assert.That(db.Patient.Where(x => x.PersonID < 0).Max(x => (int?)x.PersonID), Is.Null);
328 Assert.Catch<InvalidOperationException>(
329 () => db.Patient.Where(x => x.PersonID < 0).Select(x => x.PersonID).Max());
330 Assert.Catch<InvalidOperationException>(
331 () => db.Patient.Where(x => x.PersonID < 0).Max(x => x.PersonID));
332 });
333 }
334
335 [Test]
336 public void TestConvertFunction([IdlProviders] string providerName)
337 {
338 ForProvider(
339 providerName,
340 db =>
341 {
342 var ds = new IdlPatientSource(db);
343 var r1 = ds.Patients().ToList();
344 var r2 = ds.Persons().ToList();
345
346 Assert.That(r1, Is.Not.Empty);
347 Assert.That(r2, Is.Not.Empty);
348
349 var r3 = ds.Patients().ToIdlPatientEx(ds);
350 var r4 = r3.ToList();
351 Assert.That(r4, Is.Not.Empty);
352 });
353 }
354
355 [Test]
356 public void TestJoinOrder([IdlProviders] string providerName)
357 {
358 ForProvider(
359 providerName,
360 db =>
361 {
362 var source = new IdlPatientSource(db);
363
364 // Success when use result from second JOIN
365 var query1 = from p1 in source.GrandChilds()
366 join p2 in source.Persons() on p1.ParentID equals p2.Id
367 join p3 in source.Persons() on p1.ChildID equals p3.Id
368 select
369 new
370 {
371 p1.ChildID,
372 p1.ParentID,
373 //Parent = p2,
374 Child = p3,
375 };
376 var data1 = query1.ToList();
377
378 // Fail when use result from first JOIN
379 var query2 = from p1 in source.GrandChilds()
380 join p2 in source.Persons() on p1.ParentID equals p2.Id
381 join p3 in source.Persons() on p1.ChildID equals p3.Id
382 select
383 new
384 {
385 p1.ChildID,
386 p1.ParentID,
387 Parent = p2,
388 //Child = p3,
389 };
390 var data2 = query2.ToList();
391 });
392 }
393
394 [Test]
395 public void TestDistinctWithGroupBy([IdlProviders] string providerName)
396 {
397 ForProvider(
398 providerName,
399 db =>
400 {
401 const int parentId = 10000;
402 db.Parent.Insert(() => new Parent { ParentID = parentId, Value1 = 1 });
403 db.Parent.Insert(() => new Parent { ParentID = parentId, Value1 = 1 });
404
405 try
406 {
407 var source = db.Parent.ToList();
408
409 // Success when query is executed in memory
410 TestDistinctWithGroupBy(source.AsQueryable());
411
412 // Failed when query is executed on sql server
413 TestDistinctWithGroupBy(db.Parent);
414 }
415 finally
416 {
417 db.Parent.Delete(x => x.ParentID == parentId);
418 }
419 });
420 }
421
422 private static void TestDistinctWithGroupBy(IQueryable<Parent> source)
423 {
424 const int score = 4;
425 var q = source.Select(x => new { Key = x.Value1, MatchScore = score })
426 .Distinct();
427 var qq = q.GroupBy(
428 x => x.Key,
429 (key, x) => new { Id = key, MatchScore = x.Sum(y => y.MatchScore) })
430 .Select(x => new { x.Id, x.MatchScore });
431
432 var result = qq.ToList();
433 Assert.That(result.Select(x => x.MatchScore), Is.All.EqualTo(score));
434 }
435
436 private static IQueryable<T> GetById<T>(ITestDataContext db, int id) where T : class, IHasID
437 {
438 return db.GetTable<T>().Where(obj => obj.ID == id);
439 }
440
441 [Test]
442 public void ImplicitCastTest([IdlProviders] string providerName)
443 {
444 ForProvider(
445 providerName,
446 db =>
447 {
448 var people =
449 from p in db.Person
450 select new IdlPerson
451 {
452 Id = new ObjectId { Value = p.ID },
453 Name = p.FirstName
454 };
455
456 var sql1 = (from p in people where p.Id == 1 select p).ToString();
457 var sql2 = (from p in people where p.Id.Value == 1 select p).ToString();
458
459 Assert.That(sql1, Is.EqualTo(sql2));
460 });
461 }
462
463 [Test]
464 public void ListvsArrayTest([IdlProviders] string providerName)
465 {
466 ForProvider(
467 providerName,
468 db =>
469 {
470 var st = "John";
471
472 //SQL - x.FirstName IN ('John')
473 var queryList = from x in db.Person
474 where new List<string> { st }.Contains(x.FirstName)
475 select x.ID;
476
477 //SQL - x.FirstName IN ('J', 'o', 'h', 'n')
478 var queryArray = from x in db.Person
479 where new[] { st }.Contains(x.FirstName)
480 select x.ID;
481
482 Assert.That(queryList.ToList(), Is.EqualTo(queryArray.ToList()));
483 });
484 }
485
486 [Test]
487 public void ConcatJoinOrderByTest([IdlProviders] string providerName)
488 {
489 ForProvider(
490 providerName,
491 db =>
492 {
493 var query = from y in
494 ((from pat in db.Patient
495 where pat.Diagnosis == "a"
496 select pat)
497 .Concat
498 (
499 from pat in db.Patient
500 where pat.Diagnosis == "b"
501 select pat))
502 join person in db.Person on y.PersonID equals person.ID
503 orderby person.ID
504 select new { Id = person.ID, Id2 = y.PersonID };
505
506 Assert.That(query.ToList(), Is.Not.Null);
507 });
508 }
509
510 [Test]
511 public void TestIsContainedInArrayOfEnumValues([IdlProviders] string providerName)
512 {
513 var types2 = new[] { TypeValue.Value2, TypeValue.Value3, TypeValue.Value4 };
514
515 ForProvider(
516 providerName,
517 db =>
518 {
519 var result = (from x in db.Parent4 where types2.Contains(x.Value1) select x)
520 .ToList();
521
522 Assert.That(result, Is.Not.Null);
523 });
524 }
525
526 [Test]
527 public void TestQueryWithInterface([IdlProviders] string providerName)
528 {
529 ForProvider(
530 providerName,
531 db =>
532 {
533 var persons =
534 from x in db.Person
535 select new PersonWithObjectId
536 {
537 Id = new ObjectId { Value = x.ID },
538 FistName = x.FirstName,
539 };
540
541 // this works
542 var r1 = FilterSourceByIdDefinedInBaseClass(persons, 5).ToArray();
543 Assert.That(r1, Is.Not.Null);
544
545 // and this works
546 var r2 = FilterSourceByIdDefinedInInterface1(persons, 5).ToArray();
547 Assert.That(r2, Is.Not.Null);
548
549 // but this fails
550 var r3 = FilterSourceByIdDefinedInInterface2(persons, 5).ToArray();
551 Assert.That(r3, Is.Not.Null);
552 });
553 }
554
555 [Test]
556 public void TestBugCountWithOrderBy([IdlProviders] string providerName)
557 {
558 ForProvider(
559 providerName,
560 db =>
561 {
562 var q1 = db.Person.OrderBy(x => x.ID);
563
564 var q2 = from p in q1
565 join p2 in db.Person on p.ID equals p2.ID
566 select p2;
567
568 Assert.DoesNotThrow(() => q2.Max(x => x.ID));
569 Assert.DoesNotThrow(() => q2.Count());
570 });
571 }
572
573 [Test]
574 public void TestUpdateWithTargetByAssociationProperty([IdlProviders] string providerName)
575 {
576 TestUpdateByAssociationProperty(providerName, true);
577 }
578
579 [Test]
580 public void TestSetUpdateWithoutTargetByAssociationProperty([IdlProviders] string providerName)
581 {
582 TestUpdateByAssociationProperty(providerName, false);
583 }
584
585 private void TestUpdateByAssociationProperty(string providerName, bool useUpdateWithTarget)
586 {
587 ForProvider(
588 providerName,
589 db =>
590 {
591 const int childId = 10000;
592 const int parentId = 20000;
593
594 try
595 {
596 db.Parent.Insert(() => new Parent { ParentID = parentId });
597 db.Child.Insert(() => new Child { ChildID = childId, ParentID = parentId });
598
599 var parents = from child in db.Child
600 where child.ChildID == childId
601 select child.Parent;
602
603 if (useUpdateWithTarget)
604 {
605 // this failed for MySql and SQLite but works with MS SQL
606 Assert.DoesNotThrow(() => parents.Update(db.Parent, x => new Parent { Value1 = 5 }));
607 }
608 else
609 {
610 // this works with MySql but failed for SQLite and MS SQL
611 Assert.DoesNotThrow(() => parents.Set(x => x.Value1, 5).Update());
612 }
613 }
614 finally
615 {
616 db.Child.Delete(x => x.ChildID == childId);
617 db.Parent.Delete(x => x.ParentID == parentId);
618 }
619 });
620 }
621
622
623 private IQueryable<T> FilterSourceByIdDefinedInBaseClass<T>(IQueryable<T> source, int id)
624 where T : WithObjectIdBase
625 {
626 return from x in source where x.Id == id select x;
627 }
628
629 private IQueryable<T> FilterSourceByIdDefinedInInterface1<T>(IQueryable<T> source, int id)
630 where T : IHasObjectId1
631 {
632 return from x in source where x.Id == id select x;
633 }
634
635 private IQueryable<T> FilterSourceByIdDefinedInInterface2<T>(IQueryable<T> source, int id)
636 where T : IHasObjectId2
637 {
638 return from x in source where x.Id == id select x;
639 }
640
641 [Test]
642 public void TestComparePropertyOfEnumTypeToVaribleInSubquery([IdlProviders] string providerName)
643 {
644 ForProvider(
645 providerName,
646 db =>
647 {
648 var gender = Gender.Other;
649 var q = from x in db.Patient
650 join y in db.Person.Where(x => x.Gender == gender) on x.PersonID equals y.ID
651 select x;
652
653 var r = q.ToList();
654 Assert.That(r, Is.Not.Null);
655 });
656 }
657
658 [Test]
659 public void ConcatOrderByTest([IdlProviders] string providerName)
660 {
661 ForProvider(
662 providerName,
663 db =>
664 {
665 var q = from p in db.Person
666 where p.ID < 0
667 select new { Rank = 0, FirstName = (string)null, LastName = (string)null };
668 var q2 =
669 q.Concat(
670 from p in db.Person
671 select new { Rank = p.ID, p.FirstName, p.LastName });
672
673 var resultquery = (from x in q2 orderby x.Rank, x.FirstName, x.LastName select x).ToString();
674
675 var rqr = resultquery.LastIndexOf(
676 "ORDER BY", System.StringComparison.InvariantCultureIgnoreCase);
677 var rqp =
678 (resultquery.Substring(rqr + "ORDER BY".Length).Split(',')).Select(p => p.Trim()).ToArray();
679
680 Assert.That(rqp.Count(), Is.EqualTo(3));
681 });
682 }
683
684 [Test]
685 public void TestContainsForNullableDateTimeWithOnlyNullValue1([IdlProviders] string providerName)
686 {
687 ForProvider(
688 providerName,
689 db =>
690 {
691 var dates = new DateTime?[] { null };
692
693 // Ensures that the query works properly in memory
694 // ReSharper disable RemoveToList.2
695 var resultCount = db.Types2.ToList().Count(x => dates.Contains(x.DateTimeValue2));
696 // ReSharper restore RemoveToList.2
697 Assert.That(resultCount, Is.GreaterThan(0));
698
699 var result = db.Types2.Count(x => dates.Contains(x.DateTimeValue2));
700 Assert.That(result, Is.EqualTo(resultCount));
701 });
702 }
703
704 [Test]
705 public void TestContainsForNullableDateTimeWithOnlyNullValue2([IdlProviders] string providerName)
706 {
707 ForProvider(
708 providerName,
709 db =>
710 {
711 // Ensures that the query works properly in memory
712 // ReSharper disable RemoveToList.2
713 var resultCount = db.Types2.ToList().Count(x => new DateTime?[] { null }.Contains(x.DateTimeValue2));
714 // ReSharper restore RemoveToList.2
715 Assert.That(resultCount, Is.GreaterThan(0));
716
717 var result = db.Types2.Count(x => new DateTime?[] { null }.Contains(x.DateTimeValue2));
718 Assert.That(result, Is.EqualTo(resultCount));
719 });
720 }
721
722 [Test]
723 public void TestContainsForNullableDateTimeWithNullAndNotNullValues1([IdlProviders] string providerName)
724 {
725 ForProvider(
726 providerName,
727 db =>
728 {
729 var date = new DateTime(2009, 9, 24, 9, 19, 29, 90);
730 var dates = new DateTime?[] { null, date };
731
732 // Ensures that the query works properly in memory
733 // ReSharper disable RemoveToList.2
734 var resultCount = db.Types2.ToList().Count(x => dates.Contains(x.DateTimeValue2));
735 // ReSharper restore RemoveToList.2
736 Assert.That(resultCount, Is.GreaterThan(0));
737
738 var result = db.Types2.Count(x => dates.Contains(x.DateTimeValue2));
739 Assert.That(result, Is.EqualTo(resultCount));
740 });
741 }
742
743 [Test]
744 public void TestContainsForNullableDateTimeWithNullAndNotNullValues2([IdlProviders] string providerName)
745 {
746 ForProvider(
747 providerName,
748 db =>
749 {
750 // Ensures that the query works properly in memory
751 // ReSharper disable RemoveToList.2
752 var resultCount = db.Types2.ToList().Count(x => new DateTime?[] { null, new DateTime(2009, 9, 24, 9, 19, 29, 90) }.Contains(x.DateTimeValue2));
753 // ReSharper restore RemoveToList.2
754 Assert.That(resultCount, Is.GreaterThan(0));
755
756 var result = db.Types2.Count(x => new DateTime?[] { null, new DateTime(2009, 9, 24, 9, 19, 29, 90) }.Contains(x.DateTimeValue2));
757 Assert.That(result, Is.EqualTo(resultCount));
758 });
759 }
760
761 #region GenericQuery classes
762
763 public abstract partial class GenericQueryBase
764 {
765 private readonly IdlPatientSource m_ds;
766
767 protected GenericQueryBase(ITestDataContext ds)
768 {
769 m_ds = new IdlPatientSource(ds);
770 }
771
772 #region Object sources
773
774 protected IQueryable<IdlPerson> AllPersons
775 {
776 get { return m_ds.Persons(); }
777 }
778
779 protected IQueryable<IdlPatient> AllPatients
780 {
781 get { return m_ds.Patients(); }
782 }
783
784 protected IQueryable<IdlGrandChild> AllGrandChilds
785 {
786 get { return m_ds.GrandChilds(); }
787 }
788
789 #endregion
790
791 public abstract IEnumerable<object> Query();
792 }
793
794 public class GenericConcatQuery : GenericQueryBase
795 {
796 private String @p1;
797 private Int32 @p2;
798
799 public GenericConcatQuery(ITestDataContext ds, object[] args)
800 : base(ds)
801 {
802 @p1 = (String)args[0];
803 @p2 = (Int32)args[1];
804 }
805
806 public override IEnumerable<object> Query()
807 {
808 return (from y in AllPersons
809 select y.Name)
810 .Concat(
811 from x in AllPersons
812 from z in AllPatients
813 where (x.Name == @p1 || z.Id == new ObjectId { Value = @p2 })
814 select x.Name
815 );
816 }
817 }
818
819 public class GenericConcatJoinOrderQuery : GenericQueryBase
820 {
821 private String @p1;
822 private Int32 @p2;
823
824 public GenericConcatJoinOrderQuery(ITestDataContext ds, object[] args)
825 : base(ds)
826 {
827 @p1 = (String)args[0];
828 @p2 = (Int32)args[1];
829 }
830
831 public override IEnumerable<object> Query()
832 {
833 return (from j in
834 (from y in AllPersons
835 select new { FirstName = y.Name })
836 .Concat(
837 from x in AllPersons
838 from z in AllPatients
839 where (x.Name == @p1 || z.Id == new ObjectId { Value = @p2 })
840 select new { FirstName = x.Name }
841 )
842 join g in AllGrandChilds on j.FirstName equals @p1
843 orderby g.ParentID.Value
844 select new { FirstName = g.ParentID.Value.ToString() });
845 }
846 }
847
848 #endregion
849
850 [Test]
851 public void TestMono01()
852 {
853 ForMySqlProvider(
854 db =>
855 {
856 var ds = new IdlPatientSource(db);
857 var t = "A";
858 var query =
859 (from y in ds.Persons()
860 select y.Name)
861 .Concat(
862 from x in ds.Persons()
863 where x.Name == t
864 select x.Name
865 );
866
867 Assert.That(query.ToList(), Is.Not.Null);
868 });
869 }
870
871 [Test]
872 public void TestMono03()
873 {
874 ForMySqlProvider(
875 db => Assert.That(new GenericConcatQuery(db, new object[] { "A", 1 }).Query().ToList(), Is.Not.Null));
876 }
877
878 [Test]
879 public void TestMono04()
880 {
881 ForMySqlProvider(
882 db =>
883 Assert.That(
884 new GenericConcatJoinOrderQuery(db, new object[] { "A", 1 }).Query().ToList(), Is.Not.Null));
885 }
886
887 public static IQueryable<TSource> Concat2<TSource>(IQueryable<TSource> source1, IEnumerable<TSource> source2)
888 {
889 return source1.Provider.CreateQuery<TSource>(
890 Expression.Call(
891 null,
892 typeof (Queryable).GetMethod("Concat").MakeGenericMethod(typeof (TSource)),
893 new[] { source1.Expression, Expression.Constant(source2, typeof (IEnumerable<TSource>)) }));
894 }
895
896 [Test]
897 public void TestMonoConcat()
898 {
899 ForMySqlProvider(
900 db =>
901 {
902 var ds = new IdlPatientSource(db);
903 var t = "A";
904 var query = Concat2(
905 from y in ds.Persons() select y.Name,
906 from x in ds.Persons() where x.Name == t select x.Name);
907
908 Assert.That(query.ToList(), Is.Not.Null);
909 });
910 }
911
912 [Test]
913 public void TestMonoConcat2()
914 {
915 ForMySqlProvider(
916 db =>
917 {
918 var ds = new IdlPatientSource(db);
919 var t = "A";
920 var query1 = Concat2(
921 from y in ds.Persons() select y.Name,
922 from x in ds.Persons() where x.Name == t select x.Name);
923
924 Assert.That(query1.ToList(), Is.Not.Null);
925 });
926
927 ForMySqlProvider(
928 db =>
929 {
930 var ds = new IdlPatientSource(db);
931 var t = "A";
932 var query2 = Concat2(
933 from y in ds.Persons() select y.Name,
934 from x in ds.Persons() where x.Name == t select x.Name);
935
936 Assert.That(query2.ToList(), Is.Not.Null);
937 });
938 }
939 }
940
941 #region TestConvertFunction classes
942
943 public class IdlPatient
944 {
945 public IdlTest.ObjectId Id { get; set; }
946 }
947
948 public class IdlPerson
949 {
950 public IdlTest.ObjectId Id { get; set; }
951 public string Name { get; set; }
952 }
953
954 public class IdlGrandChild
955 {
956 public IdlTest.ObjectId ParentID { get; set; }
957 public IdlTest.ObjectId ChildID { get; set; }
958 public IdlTest.ObjectId GrandChildID { get; set; }
959 }
960
961 public class IdlPatientEx : IdlPatient
962 {
963 public IdlPerson Person { get; set; }
964 }
965
966 public class IdlPatientSource
967 {
968 private readonly ITestDataContext m_dc;
969
970 public IdlPatientSource(ITestDataContext dc)
971 {
972 m_dc = dc;
973 }
974
975 public IQueryable<IdlGrandChild> GrandChilds()
976 {
977 return m_dc.GrandChild.Select(
978 x => new IdlGrandChild
979 {
980 ChildID = new IdlTest.ObjectId { Value = x.ChildID.Value },
981 GrandChildID = new IdlTest.ObjectId { Value = x.GrandChildID.Value },
982 ParentID = new IdlTest.ObjectId { Value = x.ParentID.Value }
983 });
984 }
985
986 public IQueryable<IdlPatient> Patients()
987 {
988 return m_dc.Patient.Select(x => new IdlPatient { Id = new IdlTest.ObjectId { Value = x.PersonID }, });
989 }
990
991 public IQueryable<IdlPerson> Persons()
992 {
993 return
994 m_dc.Person.Select(
995 x => new IdlPerson { Id = new IdlTest.ObjectId { Value = x.ID }, Name = x.FirstName, });
996 }
997 }
998
999 public static class IdlPersonConverterExtensions
1000 {
1001 public static IEnumerable<IdlPatientEx> ToIdlPatientEx(
1002 this IQueryable<IdlPatient> list, IdlPatientSource source)
1003 {
1004 return from x in list
1005 join person in source.Persons() on x.Id.Value equals person.Id.Value
1006 select new IdlPatientEx
1007 {
1008 Id = x.Id,
1009 Person =
1010 new IdlPerson { Id = new IdlTest.ObjectId { Value = person.Id }, Name = person.Name, },
1011 };
1012 }
1013 }
1014
1015 #endregion
1016 }