NH-2520 - Add TimestampUtc type

Author: ramonsmits

src/NHibernate.Test/NHibernate.Test.csproj

@@ -1397,6 +1397,8 @@
     <Compile Include="TransformTests\ImplementationOfEqualityTests.cs" />
     <Compile Include="TypesTest\CharClass.cs" />
     <Compile Include="TypesTest\CharClassFixture.cs" />
+    <Compile Include="TypesTest\TimestampUtcClass.cs" />
+    <Compile Include="TypesTest\TimestampUtcTypeFixture.cs" />
     <Compile Include="TypesTest\StringTypeWithLengthFixture.cs" />
     <Compile Include="TypesTest\DateTimeClass.cs" />
     <Compile Include="TypesTest\LocalDateTimeTypeFixture.cs" />
@@ -3413,6 +3415,7 @@
     <EmbeddedResource Include="NHSpecificTest\AccessAndCorrectPropertyName\DogMapping.hbm.xml" />
     <EmbeddedResource Include="NHSpecificTest\AccessAndCorrectPropertyName\PersonMapping.hbm.xml" />
     <EmbeddedResource Include="NHSpecificTest\NH2507\Mappings.hbm.xml" />
+    <EmbeddedResource Include="TypesTest\TimestampUtcClass.hbm.xml" />
     <EmbeddedResource Include="NHSpecificTest\EntityNameAndInheritance\Mappings.hbm.xml" />
     <EmbeddedResource Include="NHSpecificTest\NH2467\Mappings.hbm.xml" />
     <EmbeddedResource Include="NHSpecificTest\NH2459\Mappings.hbm.xml" />

src/NHibernate.Test/TypesTest/TimestampUtcClass.cs

@@ -0,0 +1,11 @@
+using System;
+
+namespace NHibernate.Test.TypesTest
+{
+	public class TimestampUtcClass
+	{
+		public int Id { get; set; }
+		public DateTime Value { get; set; }
+		public DateTime Revision { get; protected set; }
+	}
+}

src/NHibernate.Test/TypesTest/TimestampUtcClass.hbm.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2" default-lazy="false">
+	<class
+		name="NHibernate.Test.TypesTest.TimestampUtcClass, NHibernate.Test"
+		table="bc_timestamputc">
+		<id name="Id" column="id">
+			<generator class="assigned" />
+		</id>
+		<version name="Revision" column="Revision" type="TimestampUtc" />
+		<property name="Value" type="TimestampUtc" />
+	</class>
+</hibernate-mapping>

src/NHibernate.Test/TypesTest/TimestampUtcTypeFixture.cs

@@ -0,0 +1,183 @@
+using System;
+using NHibernate.Type;
+using NUnit.Framework;
+
+namespace NHibernate.Test.TypesTest
+{
+	/// <summary>
+	/// Test fixture for type <see cref="TimestampUtcType"/>.
+	/// </summary>
+	[TestFixture]
+	public class TimestampUtcTypeFixture : TypeFixtureBase
+	{
+		readonly TimestampUtcType _type = NHibernateUtil.TimestampUtc;
+		readonly DateTime _utc = new DateTime(1976, 11, 30, 10, 0, 0, 300, DateTimeKind.Utc);
+		readonly DateTime _local = new DateTime(1976, 11, 30, 10, 0, 0, 300, DateTimeKind.Local);
+		readonly DateTime _unspecified = new DateTime(1976, 11, 30, 10, 0, 0, 300, DateTimeKind.Unspecified);
+
+		/// <summary>
+		/// 1976-11-30T10:00:00.3000000
+		/// </summary>
+		const long DateInTicks = 623537928003000000;
+		
+		protected override string TypeName => "TimestampUtc";
+
+		[Test]
+		public void Next()
+		{
+			var current = DateTime.Parse("2004-01-01");
+			var next = (DateTime)_type.Next(current, null);
+
+			Assert.AreEqual(DateTimeKind.Utc, next.Kind, "Kind is not Utc");
+			Assert.IsTrue(next > current, "next should be greater than current (could be equal depending on how quickly this occurs)");
+		}
+
+		/// <summary>
+		/// Perform a 'seed' and check if the result is a datetime with kind set to Utc.
+		/// </summary>
+		[Test]
+		public void Seed()
+		{
+			var type = NHibernateUtil.TimestampUtc;
+			Assert.IsTrue(type.Seed(null) is DateTime, "Seed should be DateTime");
+
+			var value = (DateTime)type.Seed(null);
+			Assert.AreEqual(DateTimeKind.Utc, value.Kind, "Kind should be Utc");
+		}
+
+		/// <summary>
+		/// Perform a basis write with a DateTime value where Kind is Local which should fail.
+		/// </summary>
+		[Test]
+		[TestCase(DateTimeKind.Unspecified)]
+		[TestCase(DateTimeKind.Local)]
+		public void LocalReadWrite_Fail(DateTimeKind kind)
+		{
+			var entity = new TimestampUtcClass
+			{
+				Id = 1,
+				Value = DateTime.SpecifyKind(DateTime.Now, kind)
+			};
+
+			using(var session = OpenSession())
+			using(var tx = session.BeginTransaction())
+			{
+				session.Save(entity);
+				Assert.That(() => session.Flush(), Throws.TypeOf<PropertyValueException>());
+				tx.Rollback();
+			}
+		}
+
+		/// <summary>
+		/// Create two session. Write entity in the first and read it in the second and compare if
+		/// the retrieved timestamp value still equals the original value.
+		/// </summary>
+		/// <remarks> This test takes the database precision into consideration.</remarks>
+		[Test]
+		public void UtcReadWrite_Success()
+		{
+			TimestampUtcClass entity;
+
+			// Save
+			using(var session = OpenSession())
+			using(var tx = session.BeginTransaction())
+			{
+				// Create a new datetime value and round it to the precision that the database supports. This
+				// code basically the same as in the implementation but here to guard posible changes.
+				var resolution = session.GetSessionImplementation().Factory.Dialect.TimestampResolutionInTicks;
+				var next = DateTime.UtcNow;
+				next = next.AddTicks(-(next.Ticks % resolution));
+
+				entity = new TimestampUtcClass
+				{
+					Id = 1,
+					Value = next
+				};
+
+				session.Save(entity);
+				tx.Commit();
+				session.Close();
+			}
+
+			// Retrieve and compare
+			using (var session = OpenSession())
+			using (var tx = session.BeginTransaction())
+			{
+				var result = session.Get<TimestampUtcClass>(entity.Id);
+				Assert.IsNotNull(result, "Entity not saved or cannot be retrieved by its key.");
+
+				// Property: Value
+				Assert.AreEqual(DateTimeKind.Utc, result.Value.Kind, "Kind is NOT Utc");
+				Assert.AreEqual(entity.Value.Ticks, result.Value.Ticks, "Value should be the same.");
+
+				// Property: Revision
+				var revision = result.Revision;
+				Assert.AreEqual(DateTimeKind.Utc, revision.Kind, "Kind is NOT Utc");
+
+				var differenceInSeconds = Math.Abs((revision - DateTime.UtcNow).TotalSeconds);
+				Assert.IsTrue(differenceInSeconds < 1d, "Difference should be less then 1 second.");
+
+				tx.Commit();
+				session.Close();
+			}
+
+			// Delete
+			using (var session = OpenSession())
+			using (var tx = session.BeginTransaction())
+			{
+				var result = session.Get<TimestampUtcClass>(entity.Id);
+				session.Delete(result);
+				tx.Commit();
+				session.Close();
+			}
+		}
+
+		/// <summary>
+		/// Tests if the type FromStringValue implementation behaves as expected.
+		/// </summary>
+		/// <param name="timestampValue"></param>
+		[Test]
+		[TestCase("2011-01-27T15:50:59.6220000+02:00")]
+		[TestCase("2011-01-27T14:50:59.6220000+01:00")]
+		[TestCase("2011-01-27T13:50:59.6220000Z")]
+		public void FromStringValue_ParseValidValues(string timestampValue)
+		{
+			var timestamp = DateTime.Parse(timestampValue);
+
+			Assert.AreEqual(DateTimeKind.Local, timestamp.Kind, "Kind is NOT Local. dotnet framework parses datetime values with kind set to Local and time correct to local timezone.");
+
+			timestamp = timestamp.ToUniversalTime();
+
+			var value = (DateTime)_type.FromStringValue(timestampValue);
+
+			Assert.AreEqual(timestamp, value, timestampValue);
+			Assert.AreEqual(DateTimeKind.Utc, value.Kind, "Kind is NOT Utc");
+		}
+
+		/// <summary>
+		/// Test the framework tostring behavior. If the test fails then the <see cref="TimestampType"/> and <see cref="TimestampUtcType"/> implemention could not work propertly at run-time.
+		/// </summary>
+		[Test, Category("Expected framework behavior")]
+		[TestCase(623537928003000000, DateTimeKind.Utc, ExpectedResult = "1976-11-30T10:00:00.3000000Z")]
+		[TestCase(623537928003000000, DateTimeKind.Unspecified, ExpectedResult = "1976-11-30T10:00:00.3000000")]
+		[TestCase(623537928003000000, DateTimeKind.Local, ExpectedResult = "1976-11-30T10:00:00.3000000+01:00",
+			Ignore = "Offset depends on which system this test is run and can currently now be influenced via the .net framework",
+			Description ="This test will ONLY succeed when the test is run on a system which if currently in a timezone with offset +01:00")]
+		public string ExpectedToStringDotnetFrameworkBehavior(long ticks, DateTimeKind kind)
+		{
+			return new DateTime(ticks, kind).ToString("o");
+		}
+
+		/// <summary>
+		/// Test the framework tostring behavior. If the test fails then the <see cref="TimestampType"/> and <see cref="TimestampUtcType"/> implemention could not work propertly at run-time.
+		/// </summary>
+		[Test, Category("Expected framework behavior")]
+		public void ExpectedIsEqualDotnetFrameworkBehavior()
+		{
+			const string assertMessage = "Values should be equal dotnet framework ignores Kind value.";
+			Assert.AreEqual(_utc, _local, assertMessage);
+			Assert.AreEqual(_utc, _unspecified, assertMessage);
+			Assert.AreEqual(_unspecified, _local, assertMessage);
+		}
+	}
+}

src/NHibernate/NHibernate.csproj

@@ -733,6 +733,7 @@
     <Compile Include="Type\UInt32Type.cs" />
     <Compile Include="Type\UInt64Type.cs" />
     <Compile Include="Type\PrimitiveType.cs" />
+    <Compile Include="Type\TimestampUtcType.cs" />
     <Compile Include="Type\YesNoType.cs" />
     <Compile Include="UnresolvableObjectException.cs" />
     <Compile Include="Util\ADOExceptionReporter.cs" />

src/NHibernate/NHibernateUtil.cs

@@ -237,6 +237,11 @@ public static IType GuessType(System.Type type)
 
 		public static readonly DbTimestampType DbTimestamp = new DbTimestampType();
 
+		/// <summary>
+		/// NHibernate timestamp utc type.
+		/// </summary>
+		public static readonly TimestampUtcType TimestampUtc = new TimestampUtcType();
+
 		/// <summary>
 		/// NHibernate TrueFalse type
 		/// </summary>

src/NHibernate/Type/TimestampType.cs

@@ -30,13 +30,25 @@ namespace NHibernate.Type
 	[Serializable]
 	public class TimestampType : PrimitiveType, IVersionType, ILiteralType
 	{
+		/// <summary>
+		/// Retrieve the current system Local time.
+		/// </summary>
+		/// <value>DateTime.Now</value>
+		protected virtual DateTime Now => DateTime.Now;
+
+		/// <summary>
+		/// Returns the DateTimeKind for type <see cref="TimestampUtcType"/>.
+		/// </summary>
+		/// <value>Returns DateTimeKind.Unspecified</value>
+		protected virtual DateTimeKind Kind => DateTimeKind.Unspecified;
+
 		public TimestampType() : base(SqlTypeFactory.DateTime)
 		{
 		}
 
 		public override object Get(DbDataReader rs, int index)
 		{
-			return Convert.ToDateTime(rs[index]);
+			return DateTime.SpecifyKind(Convert.ToDateTime(rs[index]), Kind);
 		}
 
 		public override object Get(DbDataReader rs, string name)
@@ -60,7 +72,7 @@ public override System.Type ReturnedClass
 		/// </remarks>
 		public override void Set(DbCommand st, object value, int index)
 		{
-			st.Parameters[index].Value = (value is DateTime) ? value:DateTime.Now;
+			st.Parameters[index].Value = (value is DateTime) ? value : DateTime.SpecifyKind(Now, Kind);
 		}
 
 		public override string Name
@@ -94,9 +106,9 @@ public virtual object Seed(ISessionImplementor session)
 		{
 			if (session == null)
 			{
-				return DateTime.Now;
+				return Now;
 			}
-			return Round(DateTime.Now, session.Factory.Dialect.TimestampResolutionInTicks);
+			return Round(Now, session.Factory.Dialect.TimestampResolutionInTicks);
 		}
 
 		public IComparer Comparator
@@ -108,7 +120,7 @@ public IComparer Comparator
 
 		public object StringToObject(string xml)
 		{
-			return DateTime.Parse(xml);
+			return FromStringValue(xml);
 		}
 
 		public override System.Type PrimitiveClass
@@ -126,4 +138,4 @@ public override string ObjectToSQLString(object value, Dialect.Dialect dialect)
 			return '\'' + value.ToString() + '\'';
 		}
 	}
-}
+}

src/NHibernate/Type/TimestampUtcType.cs

@@ -0,0 +1,69 @@
+using System;
+using System.Data.Common;
+
+namespace NHibernate.Type
+{
+	[Serializable]
+	public class TimestampUtcType : TimestampType
+	{
+		/// <summary>
+		/// Returns the DateTimeKind for type <see cref="TimestampUtcType"/>.
+		/// </summary>
+		/// <value>Returns DateTimeKind.Utc</value>
+		protected override DateTimeKind Kind => DateTimeKind.Utc;
+
+		/// <summary>
+		/// Retrieve the current system Utc time.
+		/// </summary>
+		/// <value>DateTime.UtcNow</value>
+		protected override DateTime Now => DateTime.UtcNow;
+
+		public override string Name => "TimestampUtc";
+
+		/// <summary>
+		/// Parse the value by the base implementation and convert it to Utc as the .net framework by default parse to a DateTime value with Kind set to Local.
+		/// </summary>
+		/// <returns>DateTime value where Kind is Utc</returns>
+		public override object FromStringValue(string xml)
+		{
+			return ((DateTime) base.FromStringValue(xml)).ToUniversalTime();
+		}
+
+		/// <summary>
+		/// Validate the passed DateTime value if Kind is set to Utc and passes value to base implementation (<see cref="TimestampType.Set(DbCommand, object, int )"/>).
+		/// </summary>
+		/// <exception cref="ArgumentException">Thrown when Kind is NOT Utc.</exception>
+		public override void Set(DbCommand st, object value, int index)
+		{
+			if (value is DateTime)
+			{
+				var v = (DateTime) value;
+				if (v.Kind != DateTimeKind.Utc) throw new ArgumentException("Kind is NOT Utc", nameof(value));
+			}
+
+			base.Set(st, value, index);
+		}
+
+		/// <summary>
+		/// Compares two DateTime object and also compare its Kind which is not used by the .net framework DateTime.Equals implementation.
+		/// </summary>
+		/// <param name="x"></param>
+		/// <param name="y"></param>
+		/// <returns></returns>
+		public override bool IsEqual(object x, object y)
+		{
+			return base.IsEqual(x, y) && ((DateTime) x).Kind == ((DateTime) y).Kind;
+		}
+
+		/// <summary>
+		/// Retrieve the string representation of the timestamp object. This is in the following format:
+		/// <code>
+		/// 2011-01-27T14:50:59.6220000Z
+		/// </code>
+		/// </summary>
+		public override string ToString(object val)
+		{
+			return ((DateTime) val).ToString("o");
+		}
+	}
+}

src/NHibernate/Type/TypeFactory.cs

@@ -262,6 +262,7 @@ private static void RegisterBuiltInTypes()
 
 			RegisterType(NHibernateUtil.Date, new[] { "date" });
 			RegisterType(NHibernateUtil.Timestamp, new[] { "timestamp" });
+			RegisterType(NHibernateUtil.TimestampUtc, new[] { "timestamputc" });
 			RegisterType(NHibernateUtil.DbTimestamp, new[] { "dbtimestamp" });
 			RegisterType(NHibernateUtil.Time, new[] { "time" });
 			RegisterType(NHibernateUtil.TrueFalse, new[] { "true_false" });