{STATIC} hippo

...on becoming a great developer... 		MCTS: .NET Framework 3.5, ASP.NET Applications
posts - 29, comments - 6, trackbacks - 0

My Links

Twitter

Archives

Post Categories

Thursday, January 07, 2010

Calendar sizes: DateTime vs Nullable SqlDateTime in NHibernate

 

Does size matter?

.NET’s DateTime class supports a range between 01/01/0001 00:00:00 and 12/31/9999 23:59:59.9999999.  Sql Server’s calendar is not quite as big – it starts at 1/1/1753.  Therefore, if you have an object with a DateTime that’s set to DateTime.MinValue (or any other date before 1/1/1753) and you try to save that to a database, you’ll get the following exception:

SqlDateTime overflow. Must be between 1/1/1753 12:00:00 AM and 12/31/9999 11:59:59 PM.

This recently got in my way.  I’m building an application on top of a legacy database.  There’s a table with a CreatedDate column that’s nullable.  However, in my domain model I didn’t want CreatedDate to be a Nullable<DateTime> because everything should have a CreatedDate – is there anything that wasn’t created at some point in time?

My object looks like this:

   1: public class MyObject
   2: {
   3:     public MyObject()
   4:     {
   5:         CreatedDate = DateTime.Now;
   6:     }
   7:  
   8:     public virtual string Name { get; set; }
   9:     public virtual DateTime CreatedDate { get; protected set; }
  10: }

Existing data in legacy database

The problem is that many of the existing entries in the database have a NULL entry for CreatedDate.  Because of this, CreatedDate will be set to DateTime.MinValue.  When I tried to save the object back to the database I got the above mentioned SqlDateTime overflow exception.

Going forward I don’t want any more NULL entries, but I don’t have the ability to update all existing NULLs to some arbitrary date (without having a whole back and forth with the DBAs).  What I decided would be the best idea would be to support NULL entries in the DB transparently – NULL entries will map to DateTime.MinValue on the GET side, and DateTime.MinValue will map to NULL on the UPDATE/SAVE side.  Since a new object always has its CreatedDate property set to DateTime.Now on instantiation, only really old objects will show 1/1/0001 as their created date in the system.

Implementation of IUserType

NHibernate has an IUserType interface which allows you to specify your own type for saving and retrieving data.  Here’s what I wrote to handle my requirements:

   1: public class NullDateTimeAsMinDateType : IUserType
   2:     {
   3:         public new bool Equals(object x, object y)
   4:         {
   5:             if (ReferenceEquals(x, y))
   6:                 return true;
   7:             if (x == null || y == null)
   8:                 return false;
   9:             return x.Equals(y);
  10:         }
  11:         #region IUserType Members
  12:  
  13:         public object Assemble(object cached, object owner)
  14:         {
  15:             return cached;
  16:         }
  17:  
  18:         public object DeepCopy(object value)
  19:         {
  20:             return value;
  21:         }
  22:  
  23:         public object Disassemble(object value)
  24:         {
  25:             return value;
  26:         }
  27:  
  28:         public int GetHashCode(object x)
  29:         {
  30:             return x == null ? typeof(DateTime).GetHashCode() : x.GetHashCode();
  31:         }
  32:  
  33:         public bool IsMutable
  34:         {
  35:             get { return false; }
  36:         }
  37:  
  38:         public object NullSafeGet(System.Data.IDataReader rs, string[] names, object owner)
  39:         {
  40:             var obj = NHibernateUtil.DateTime.NullSafeGet(rs, names[0]);
  41:             if (obj == null)
  42:                 return DateTime.MinValue;
  43:  
  44:             DateTime dateTime = (DateTime) obj;
  45:             return dateTime;
  46:         }
  47:  
  48:         public void NullSafeSet(System.Data.IDbCommand cmd, object value, int index)
  49:         {
  50:             if (value == null)
  51:             {
  52:                 ((IDataParameter)cmd.Parameters[index]).Value = DBNull.Value;
  53:                 return;
  54:             }
  55:             DateTime dateTime = (DateTime)value;
  56:             if (dateTime.CompareTo(System.Data.SqlTypes.SqlDateTime.MinValue.Value) < 0)
  57:                 ((IDataParameter)cmd.Parameters[index]).Value = DBNull.Value;
  58:             else
  59:                 ((IDataParameter)cmd.Parameters[index]).Value = dateTime;
  60:         }
  61:  
  62:         public object Replace(object original, object target, object owner)
  63:         {
  64:             return original;
  65:         }
  66:  
  67:         public Type ReturnedType
  68:         {
  69:             get { return typeof(DateTime); }
  70:         }
  71:  
  72:         public NHibernate.SqlTypes.SqlType[] SqlTypes
  73:         {
  74:             get { return new[] { NHibernateUtil.DateTime.SqlType }; }
  75:         }
  76:  
  77:         #endregion
  78:     }

 

I’m using FluentNHibernate, so my mapping looks like:

   1: Map(x => x.CreateDDate)
   2:     .Column("create_date")
   3:     .CustomType<NullDateTimeAsMinDateType>()
   4:     .Nullable();

 

That’s it.  Now the CreatedDate column in the DB doesn’t have to get touched and SQL Server’s date fields play nice with .NET DateTime.

posted @ Thursday, January 07, 2010 1:06 PM | Feedback (0) |

Powered by:

Copyright © Noah