NHibernate nullable column mapped to not null property

I'm having issues with wrong NHibernate mappings when there is a nullable database field and developer forget to declare it nullable in the corresponding .Net Entity. Example:

Table:

CREATE TABLE myTable
(
   ID int NOT NULL,
   Total int NOT NULL,
   Discount int NULL --Nullable field
)

INSERT INTO myTable VALUES (1, 10, NULL)

C# Entity:

public class MyTable{
   public int ID { get; set; }
   public int Total { get; set; }
   public int Discount { get; set; } //not declared as nullable by mistake
}

NHibernate Mapping:

public class MyTableMap : ClassMap<MyTable>
{
    public MyTableMap()
    {
        Table("dbo.myTable");
        Id(x => x.ID).GeneratedBy.Assigned().Column("ID");
        Map(x => x.Total).Column("Total");
        Map(x => x.Discount).Column("Discount"); //setting mapping to .Nullable() doesn't change the behaviour
    }
}

When i try to load the entity:

session.Get<MyTable>(1);

I would expect to get an exception, because the Discount field is null, but instead, NHibernate silently load the entity with default value 0 and then updates the database table at the first session.Flush(), even if i don't change any other value of the entity. That's even worse with datetime fields, because default value of .Net DateTime is '01/01/0001' and i get the exception:

The conversion of a datetime2 data type to a datetime data type resulted in an out-of-range value

Did anyone else faced the same issue? Is there any configuration in SessionFactory to force NHibernate to throw an exception when a NULL column is mapped to non nullable .Net property? It's difficult to get fix it by checking every single mapping of every single property and column, especially when you work on someone else's code.

Following the suggestion in comments, i wrote a few conventions for primitive types that throws an exception on NullSafeGet method when database value is NULL and property is not declared as nullable.

For example, following is the custom type to apply to Int properties:

public class IntNotNullableType : Int32Type
{
    public override object NullSafeGet(DbDataReader rs, string name, ISessionImplementor session)
    {
        //Check if value returned by database is null, then throw an exception. 
        //Unfortunately column name is something like col_2_0_, but you should be able to see the full query in exception log, so you can find the wrong mapping
        if (rs.IsDBNull(name))
            throw new NoNullAllowedException("Column " + name + " returned NULL value for not nullable property");
        return base.NullSafeGet(rs, name, session);
    }
}

The convention:

public class IntNotNullableTypeConvention : IPropertyConvention, IPropertyConventionAcceptance
{
    public void Accept(IAcceptanceCriteria<IPropertyInspector> criteria)
    {
        criteria.Expect(x => x.Property.PropertyType == typeof(int) && Nullable.GetUnderlyingType(x.Property.PropertyType) == null); //apply to all int properties NOT declared as nullable (int? or Nullable<int>)
    }

    public void Apply(IPropertyInstance instance)
    {
        instance.CustomType(typeof(IntNotNullableType));
    }
}

And finally add the convention in SessionFactory:

public static class SessionFactoryBuilder
{
    public static ISessionFactory Build(string connectionString)
    {
        return Fluently
            .Configure()
            .Database(() =>
            {
                return MsSqlConfiguration
                        .MsSql2012
                        .ConnectionString(connectionString);
            })
            .Mappings(m => m.FluentMappings.AddFromAssembly(Assembly.GetExecutingAssembly())
            .Conventions.Add<IntNotNullableTypeConvention>() //add the convention
           )
            .BuildSessionFactory();
    }
}

You can do the same for all other primitive types, such as DateTime, bool, double etc. Just create a new Type and Convention, inheriting from the correct type.

Example for datetime:

public class DateTimeNotNullableType : DateTimeType
{
    public override object NullSafeGet(DbDataReader rs, string name, ISessionImplementor session)
    {
        if (rs.IsDBNull(name))
            throw new NoNullAllowedException("Column " + name + " returned NULL value for not nullable property");
        return base.NullSafeGet(rs, name, session);
    }
}


public class DateTimeNotNullableTypeConvention : IPropertyConvention, IPropertyConventionAcceptance
{
    public void Accept(IAcceptanceCriteria<IPropertyInspector> criteria)
    {
        criteria.Expect(x => x.Property.PropertyType == typeof(DateTime) && Nullable.GetUnderlyingType(x.Property.PropertyType) == null);
    }

    public void Apply(IPropertyInstance instance)
    {
        instance.CustomType(typeof(DateTimeNotNullableType));
    }
}


public static ISessionFactory Build(string connectionString)
{
    return Fluently
        .Configure()
        .Database(() =>
        {
            return MsSqlConfiguration
                        .MsSql2012
                        .ConnectionString(connectionString);
        })
        .Mappings(m => m.FluentMappings.AddFromAssembly(Assembly.GetExecutingAssembly())
        .Conventions.Add<IntNotNullableTypeConvention>() //add the convention
        .Conventions.Add<DateTimeNotNullableTypeConvention>()
        )
        .BuildSessionFactory();
 }