NH-3524 - Add support for DateTimeOffset properties in QueryOver

Author: hazzik

src/NHibernate.Test/Criteria/Lambda/FunctionsIntegrationFixture.cs

@@ -91,7 +91,7 @@ public void YearPartSingleOrDefault()
 		}
 
 		[Test]
-		public void SelectAvg()
+		public void SelectAvgYearPart()
 		{
 			using (var s = OpenSession())
 			using (s.BeginTransaction())
@@ -168,7 +168,7 @@ public void MonthPartEqualsDayPart()
 		}
 
 		[Test]
-		public void Order()
+		public void OrderByYearPart()
 		{
 			using (var s = OpenSession())
 			using (s.BeginTransaction())
@@ -183,5 +183,100 @@ public void Order()
 				persons[2].Name.Should().Be("pP3");
 			}
 		}
+
+		[Test]
+		public void YearEqual()
+		{
+			using (var s = OpenSession())
+			using (s.BeginTransaction())
+			{
+				var persons = s.QueryOver<Person>()
+					.Where(p => p.BirthDate.Year == 2008)
+					.List();
+
+				persons.Count.Should().Be(1);
+				persons[0].Name.Should().Be("p2");
+			}
+		}
+
+		[Test]
+		public void YearIsIn()
+		{
+			using (var s = OpenSession())
+			using (s.BeginTransaction())
+			{
+				var persons = s.QueryOver<Person>()
+					.Where(p => p.BirthDate.Year.IsIn(new[] { 2008, 2009 }))
+					.OrderBy(p => p.Name).Asc
+					.List();
+
+				persons.Count.Should().Be(2);
+				persons[0].Name.Should().Be("p1");
+				persons[1].Name.Should().Be("p2");
+			}
+		}
+
+		[Test]
+		public void YearSingleOrDefault()
+		{
+			using (var s = OpenSession())
+			using (s.BeginTransaction())
+			{
+				var yearOfBirth = s.QueryOver<Person>()
+					.Where(p => p.Name == "p2")
+					.Select(p => p.BirthDate.Year)
+					.SingleOrDefault<object>();
+
+				yearOfBirth.GetType().Should().Be(typeof(int));
+				yearOfBirth.Should().Be(2008);
+			}
+		}
+
+		[Test]
+		public void SelectAvgYear()
+		{
+			using (var s = OpenSession())
+			using (s.BeginTransaction())
+			{
+				var avgYear = s.QueryOver<Person>()
+					.SelectList(list => list.SelectAvg(p => p.BirthDate.Year))
+					.SingleOrDefault<object>();
+
+				avgYear.GetType().Should().Be(typeof(double));
+				string.Format("{0:0}", avgYear).Should().Be("2008");
+			}
+		}
+
+		[Test]
+		public void OrderByYear()
+		{
+			using (var s = OpenSession())
+			using (s.BeginTransaction())
+			{
+				var persons = s.QueryOver<Person>()
+					.OrderBy(p => p.BirthDate.Year).Desc
+					.List();
+
+				persons.Count.Should().Be(3);
+				persons[0].Name.Should().Be("p1");
+				persons[1].Name.Should().Be("p2");
+				persons[2].Name.Should().Be("pP3");
+			}
+		}
+
+		[Test]
+		public void MonthEqualsDay()
+		{
+			using (var s = OpenSession())
+			using (s.BeginTransaction())
+			{
+				var persons = s.QueryOver<Person>()
+					.Where(p => p.BirthDate.Month == p.BirthDate.Day)
+					.List();
+
+				persons.Count.Should().Be(1);
+				persons[0].Name.Should().Be("p2");
+			}
+		}
 	}
 }

src/NHibernate.Test/Criteria/Lambda/IntegrationFixture.cs

@@ -315,6 +315,34 @@ public void RowCount()
 			}
 		}
 
+		[Test]
+		public void FunctionsOrder()
+		{
+			using (ISession s = OpenSession())
+			using (ITransaction t = s.BeginTransaction())
+			{
+				s.Save(new Person() { Name = "p2", BirthDate = new DateTime(2008, 07, 06) });
+				s.Save(new Person() { Name = "p1", BirthDate = new DateTime(2009, 08, 07) });
+				s.Save(new Person() { Name = "p3", BirthDate = new DateTime(2007, 06, 05) });
+
+				t.Commit();
+			}
+
+			using (ISession s = OpenSession())
+			using (s.BeginTransaction())
+			{
+			    var persons =
+			        s.QueryOver<Person>()
+			            .OrderBy(p => p.BirthDate.Year).Desc
+			            .List();
+
+			    persons.Count.Should().Be(3);
+			    persons[0].Name.Should().Be("p1");
+			    persons[1].Name.Should().Be("p2");
+			    persons[2].Name.Should().Be("p3");
+			}
+		}
+
 		[Test]
 		public void MultiCriteria()
 		{

src/NHibernate.Test/Criteria/Lambda/Mappings.hbm.xml

@@ -11,6 +11,7 @@
 		<property name="Name" />
 		<property name="Age" />
 		<property name="BirthDate" />
+		<property name="BirthDateAsDateTimeOffset" />
 		<property name="Blood" />
 		<component name="Detail" class="PersonDetail">
 			<property name="MaidenName" />

src/NHibernate.Test/Criteria/Lambda/Model.cs

@@ -19,6 +19,7 @@ public Person()
 			Children = new List<Child>();
 			Blood = 'O';
 			BirthDate = new DateTime(1950, 01, 01);
+			BirthDateAsDateTimeOffset = new DateTimeOffset(BirthDate);
 		}
 
 		public static string StaticName;
@@ -33,6 +34,7 @@ public Person()
 		public virtual bool					IsParent	{ get; set; }
 		public virtual char					Blood		{ get; set; }
 		public virtual DateTime				BirthDate	{ get; set; }
+		public virtual DateTimeOffset		BirthDateAsDateTimeOffset	{ get; set; }
 		public virtual PersonDetail			Detail		{ get; set; }
 
 		public virtual int?					NullableAge			{ get; set; }

src/NHibernate.Test/Criteria/Lambda/ProjectionsFixture.cs

@@ -146,7 +146,21 @@ public void SelectSingleFunction()
 
 			var actual =
 				CreateTestQueryOver<Person>()
-					.Select(p => p.BirthDate.YearPart());
+					.Select(p => p.BirthDate.Year);
+
+			AssertCriteriaAreEqual(expected, actual);
+		}
+
+		[Test]
+		public void SelectSingleFunctionOfDateTimeOffset()
+		{
+			ICriteria expected =
+				CreateTestCriteria(typeof(Person))
+					.SetProjection(Projections.SqlFunction("year", NHibernateUtil.Int32, Projections.Property("BirthDateAsDateTimeOffset")));
+
+			var actual =
+				CreateTestQueryOver<Person>()
+					.Select(p => p.BirthDateAsDateTimeOffset.Year);
 
 			AssertCriteriaAreEqual(expected, actual);
 		}
@@ -164,8 +178,27 @@ public void SelectMultipleFunction()
 			var actual =
 				CreateTestQueryOver<Person>(() => personAlias)
 					.SelectList(list => list
-						.Select(p => p.BirthDate.YearPart())
-						.Select(() => personAlias.BirthDate.MonthPart()));
+						.Select(p => p.BirthDate.Year)
+						.Select(() => personAlias.BirthDate.Month));
+
+			AssertCriteriaAreEqual(expected, actual);
+		}
+
+		[Test]
+		public void SelectMultipleFunctionOfDateTimeOffset()
+		{
+			ICriteria expected =
+				CreateTestCriteria(typeof(Person), "personAlias")
+					.SetProjection(Projections.ProjectionList()
+						.Add(Projections.SqlFunction("year", NHibernateUtil.Int32, Projections.Property("BirthDateAsDateTimeOffset")))
+						.Add(Projections.SqlFunction("month", NHibernateUtil.Int32, Projections.Property("personAlias.BirthDateAsDateTimeOffset"))));
+
+			Person personAlias = null;
+			var actual =
+				CreateTestQueryOver<Person>(() => personAlias)
+					.SelectList(list => list
+						.Select(p => p.BirthDateAsDateTimeOffset.Year)
+						.Select(() => personAlias.BirthDateAsDateTimeOffset.Month));
 
 			AssertCriteriaAreEqual(expected, actual);
 		}

src/NHibernate.Test/Criteria/Lambda/QueryOverFixture.cs

@@ -630,7 +630,7 @@ public void OrderBy()
 		}
 
 		[Test]
-		public void OrderByFunction()
+		public void OrderByYearPartFunction()
 		{
 			ICriteria expected =
 				CreateTestCriteria(typeof(Person), "personAlias")
@@ -644,6 +644,36 @@ public void OrderByFunction()
 			AssertCriteriaAreEqual(expected, actual);
 		}
 
+		[Test]
+		public void OrderByYearFunction()
+		{
+			ICriteria expected =
+				CreateTestCriteria(typeof(Person), "personAlias")
+					.AddOrder(Order.Desc(Projections.SqlFunction("year", NHibernateUtil.Int32, Projections.Property("personAlias.BirthDate"))));
+
+			Person personAlias = null;
+			IQueryOver<Person> actual =
+				CreateTestQueryOver<Person>(() => personAlias)
+					.OrderBy(() => personAlias.BirthDate.Year).Desc;
+
+			AssertCriteriaAreEqual(expected, actual);
+		}
+
+		[Test]
+		public void OrderByFunctionOfDateTimeOffset()
+		{
+			ICriteria expected =
+				CreateTestCriteria(typeof(Person), "personAlias")
+					.AddOrder(Order.Desc(Projections.SqlFunction("year", NHibernateUtil.Int32, Projections.Property("personAlias.BirthDateAsDateTimeOffset"))));
+
+			Person personAlias = null;
+			IQueryOver<Person> actual =
+				CreateTestQueryOver<Person>(() => personAlias)
+					.OrderBy(() => personAlias.BirthDateAsDateTimeOffset.Year).Desc;
+
+			AssertCriteriaAreEqual(expected, actual);
+		}
+
 		[Test]
 		public void AllowSingleCallSyntax()
 		{

src/NHibernate.Test/Criteria/Lambda/RestrictionsFixture.cs

@@ -258,6 +258,8 @@ public void RestrictionsExtensions()
 		[Test]
 		public void FunctionExtensions()
 		{
+			var date = new DateTime(1970, 1, 1);
+
 			ICriteria expected =
 				CreateTestCriteria(typeof(Person))
 					.Add(Restrictions.Eq(Projections.SqlFunction("year", NHibernateUtil.Int32, Projections.Property("BirthDate")), 1970))
@@ -266,6 +268,14 @@ public void FunctionExtensions()
 					.Add(Restrictions.Eq(Projections.SqlFunction("hour", NHibernateUtil.Int32, Projections.Property("BirthDate")), 1))
 					.Add(Restrictions.Eq(Projections.SqlFunction("minute", NHibernateUtil.Int32, Projections.Property("BirthDate")), 1))
 					.Add(Restrictions.Eq(Projections.SqlFunction("second", NHibernateUtil.Int32, Projections.Property("BirthDate")), 1))
+					.Add(Restrictions.Eq(Projections.SqlFunction("date", NHibernateUtil.Date, Projections.Property("BirthDate")), date))
+					.Add(Restrictions.Eq(Projections.SqlFunction("date", NHibernateUtil.Date, Projections.Property("BirthDateAsDateTimeOffset")), date))
+					.Add(Restrictions.Eq(Projections.SqlFunction("year", NHibernateUtil.Int32, Projections.Property("BirthDateAsDateTimeOffset")), 1970))
+					.Add(Restrictions.Eq(Projections.SqlFunction("day", NHibernateUtil.Int32, Projections.Property("BirthDateAsDateTimeOffset")), 1))
+					.Add(Restrictions.Eq(Projections.SqlFunction("month", NHibernateUtil.Int32, Projections.Property("BirthDateAsDateTimeOffset")), 1))
+					.Add(Restrictions.Eq(Projections.SqlFunction("hour", NHibernateUtil.Int32, Projections.Property("BirthDateAsDateTimeOffset")), 1))
+					.Add(Restrictions.Eq(Projections.SqlFunction("minute", NHibernateUtil.Int32, Projections.Property("BirthDateAsDateTimeOffset")), 1))
+					.Add(Restrictions.Eq(Projections.SqlFunction("second", NHibernateUtil.Int32, Projections.Property("BirthDateAsDateTimeOffset")), 1))
 					.Add(Restrictions.Eq(Projections.SqlFunction("sqrt", NHibernateUtil.Double, Projections.Property("Height")), 10d))
 					.Add(Restrictions.Eq(Projections.SqlFunction("lower", NHibernateUtil.String, Projections.Property("Name")), "test"))
 					.Add(Restrictions.Eq(Projections.SqlFunction("upper", NHibernateUtil.String, Projections.Property("Name")), "TEST"))
@@ -282,12 +292,20 @@ public void FunctionExtensions()
 
 			IQueryOver<Person> actual =
 				CreateTestQueryOver<Person>()
-					.Where(p => p.BirthDate.YearPart() == 1970)
-					.And(p => p.BirthDate.DayPart() == 1)
-					.And(p => p.BirthDate.MonthPart() == 1)
-					.And(p => p.BirthDate.HourPart() == 1)
-					.And(p => p.BirthDate.MinutePart() == 1)
-					.And(p => p.BirthDate.SecondPart() == 1)
+					.Where(p => p.BirthDate.Year == 1970)
+					.And(p => p.BirthDate.Day == 1)
+					.And(p => p.BirthDate.Month == 1)
+					.And(p => p.BirthDate.Hour == 1)
+					.And(p => p.BirthDate.Minute == 1)
+					.And(p => p.BirthDate.Second == 1)
+					.And(p => p.BirthDate.Date == date)
+					.And(p => p.BirthDateAsDateTimeOffset.Date == date)
+					.And(p => p.BirthDateAsDateTimeOffset.Year == 1970)
+					.And(p => p.BirthDateAsDateTimeOffset.Day == 1)
+					.And(p => p.BirthDateAsDateTimeOffset.Month == 1)
+					.And(p => p.BirthDateAsDateTimeOffset.Hour == 1)
+					.And(p => p.BirthDateAsDateTimeOffset.Minute == 1)
+					.And(p => p.BirthDateAsDateTimeOffset.Second == 1)
 					.And(p => p.Height.Sqrt() == 10)
 					.And(p => p.Name.Lower() == "test")
 					.And(p => p.Name.Upper() == "TEST")
@@ -316,11 +334,9 @@ public void FunctionExtensionsProperty()
 
 			IQueryOver<Person> actual =
 				CreateTestQueryOver<Person>()
-					.Where(p => p.BirthDate.MonthPart() == p.BirthDate.DayPart());
+					.Where(p => p.BirthDate.Month == p.BirthDate.Day);
 
 			AssertCriteriaAreEqual(expected, actual);
 		}
-
 	}
-
 }