Fix the any handling without meta-values

fredericDelaporte · fredericDelaporte · commit 99dc4a9bc570 · 2018-11-13T13:10:29.000+01:00
diff --git a/doc/reference/modules/basic_mapping.xml b/doc/reference/modules/basic_mapping.xml
@@ -3364,8 +3364,8 @@
                 database column values to persistent classes that have identifier properties of the type specified by
                 <literal>id-type</literal>. If the meta-type is <literal>class</literal>, nothing else is required.
                 The class full name will be persisted in the database as the type of the associated entity.
-                On the other hand, if it is a basic type like <literal>string</literal> or
-                <literal>char</literal>, you must specify the mapping from values to classes.
+                On the other hand, if it is a basic type like <literal>int</literal> or <literal>char</literal>, you
+                must specify the mapping from values to classes. Here is an example with <literal>string</literal>.
             </para>
 
             <programlisting><![CDATA[<any name="being" id-type="long" meta-type="string">
@@ -3376,6 +3376,11 @@
     <column name="id"/>
 </any>]]></programlisting>
 
+            <para>
+                String types are a special case: they can be used without meta-values, in which case they will behave
+                much like the <literal>class</literal> meta-type.
+            </para>
+
             <programlistingco>
                 <areaspec>
                     <area id="any1" coords="2 55"/>
diff --git a/src/NHibernate.Test/Async/CacheTest/SerializationFixture.cs b/src/NHibernate.Test/Async/CacheTest/SerializationFixture.cs
@@ -199,7 +199,7 @@ private object[] GetAllKnownTypeValues()
 				{NHibernateUtil.TrueFalse, false},
 				{NHibernateUtil.YesNo, true},
 				{NHibernateUtil.Class, typeof(IType)},
-				{NHibernateUtil.ClassMetaType, entityName},
+				{NHibernateUtil.MetaType, entityName},
 				{NHibernateUtil.Serializable, new MyEntity {Id = 1}},
 				{NHibernateUtil.Object, new MyEntity {Id = 10}},
 				{NHibernateUtil.AnsiChar, 'a'},
diff --git a/src/NHibernate.Test/Async/Legacy/FooBarTest.cs b/src/NHibernate.Test/Async/Legacy/FooBarTest.cs
@@ -5180,8 +5180,13 @@ public async Task AnyAsync()
 			s.Close();
 
 			s = OpenSession();
-			IList list = await (s.CreateQuery("from Bar bar where bar.Object.id = ? and bar.Object.class = ?")
-				.SetParameter(0, oid, NHibernateUtil.Int64).SetParameter(1, typeof(One).FullName, NHibernateUtil.ClassMetaType).ListAsync());
+			var list = await (s.CreateQuery("from Bar bar where bar.Object.id = ? and bar.Object.class = ?")
+#pragma warning disable 618
+			              .SetParameter(0, oid, NHibernateUtil.Int64).SetParameter(1, typeof(One).FullName, NHibernateUtil.ClassMetaType).ListAsync());
+#pragma warning restore 618
+			Assert.AreEqual(1, list.Count);
+			list = await (s.CreateQuery("from Bar bar where bar.Object.id = ? and bar.Object.class = ?")
+				.SetParameter(0, oid, NHibernateUtil.Int64).SetParameter(1, typeof(One).FullName, NHibernateUtil.MetaType).ListAsync());
 			Assert.AreEqual(1, list.Count);
 
 			// this is a little different from h2.0.3 because the full type is stored, not
diff --git a/src/NHibernate.Test/CacheTest/SerializationFixture.cs b/src/NHibernate.Test/CacheTest/SerializationFixture.cs
@@ -188,7 +188,7 @@ private object[] GetAllKnownTypeValues()
 				{NHibernateUtil.TrueFalse, false},
 				{NHibernateUtil.YesNo, true},
 				{NHibernateUtil.Class, typeof(IType)},
-				{NHibernateUtil.ClassMetaType, entityName},
+				{NHibernateUtil.MetaType, entityName},
 				{NHibernateUtil.Serializable, new MyEntity {Id = 1}},
 				{NHibernateUtil.Object, new MyEntity {Id = 10}},
 				{NHibernateUtil.AnsiChar, 'a'},
diff --git a/src/NHibernate.Test/Legacy/FooBarTest.cs b/src/NHibernate.Test/Legacy/FooBarTest.cs
@@ -5168,8 +5168,13 @@ public void Any()
 			s.Close();
 
 			s = OpenSession();
-			IList list = s.CreateQuery("from Bar bar where bar.Object.id = ? and bar.Object.class = ?")
-				.SetParameter(0, oid, NHibernateUtil.Int64).SetParameter(1, typeof(One).FullName, NHibernateUtil.ClassMetaType).List();
+			var list = s.CreateQuery("from Bar bar where bar.Object.id = ? and bar.Object.class = ?")
+#pragma warning disable 618
+			              .SetParameter(0, oid, NHibernateUtil.Int64).SetParameter(1, typeof(One).FullName, NHibernateUtil.ClassMetaType).List();
+#pragma warning restore 618
+			Assert.AreEqual(1, list.Count);
+			list = s.CreateQuery("from Bar bar where bar.Object.id = ? and bar.Object.class = ?")
+				.SetParameter(0, oid, NHibernateUtil.Int64).SetParameter(1, typeof(One).FullName, NHibernateUtil.MetaType).List();
 			Assert.AreEqual(1, list.Count);
 
 			// this is a little different from h2.0.3 because the full type is stored, not
diff --git a/src/NHibernate.Test/NHSpecificTest/GH1774/Implicit/ImplicitMetaTypeFixture.cs b/src/NHibernate.Test/NHSpecificTest/GH1774/Implicit/ImplicitMetaTypeFixture.cs
@@ -2,7 +2,7 @@
 
 namespace NHibernate.Test.NHSpecificTest.GH1774.Implicit
 {
-	[TestFixture, Ignore("Not fixed yet")]
+	[TestFixture]
 	public class ImplicitMetaTypeFixture : FixtureBase
 	{
 	}
diff --git a/src/NHibernate/Async/Type/ClassMetaType.cs b/src/NHibernate/Async/Type/ClassMetaType.cs
@@ -17,7 +17,7 @@ namespace NHibernate.Type
 {
 	using System.Threading.Tasks;
 	using System.Threading;
-	public partial class ClassMetaType : AbstractType, IMetaType
+	public partial class ClassMetaType : AbstractType
 	{
 
 		public override Task<object> NullSafeGetAsync(DbDataReader rs, string[] names, ISessionImplementor session, object owner, CancellationToken cancellationToken)
diff --git a/src/NHibernate/Async/Type/MetaType.cs b/src/NHibernate/Async/Type/MetaType.cs
@@ -13,27 +13,24 @@
 using System.Data.Common;
 using NHibernate.Engine;
 using NHibernate.SqlTypes;
-using NHibernate.Util;
 
 namespace NHibernate.Type
 {
 	using System.Threading.Tasks;
 	using System.Threading;
-	public partial class MetaType : AbstractType, IMetaType
+	public partial class MetaType : AbstractType
 	{
 
 		public override async Task<object> NullSafeGetAsync(DbDataReader rs, string[] names, ISessionImplementor session, object owner, CancellationToken cancellationToken)
 		{
 			cancellationToken.ThrowIfCancellationRequested();
-			object key = await (baseType.NullSafeGetAsync(rs, names, session, owner, cancellationToken)).ConfigureAwait(false);
-			return key == null ? null : values[key];
+			return GetValueForKey(await (_baseType.NullSafeGetAsync(rs, names, session, owner, cancellationToken)).ConfigureAwait(false));
 		}
 
-		public override async Task<object> NullSafeGetAsync(DbDataReader rs,string name,ISessionImplementor session,object owner, CancellationToken cancellationToken)
+		public override async Task<object> NullSafeGetAsync(DbDataReader rs, string name, ISessionImplementor session, object owner, CancellationToken cancellationToken)
 		{
 			cancellationToken.ThrowIfCancellationRequested();
-			object key = await (baseType.NullSafeGetAsync(rs, name, session, owner, cancellationToken)).ConfigureAwait(false);
-			return key == null ? null : values[key];
+			return GetValueForKey(await (_baseType.NullSafeGetAsync(rs, name, session, owner, cancellationToken)).ConfigureAwait(false));
 		}
 
 		public override Task NullSafeSetAsync(DbCommand st, object value, int index, bool[] settable, ISessionImplementor session, CancellationToken cancellationToken)
@@ -53,13 +50,25 @@ public override Task NullSafeSetAsync(DbCommand st, object value, int index, boo
 			}
 		}
 
-		public override Task NullSafeSetAsync(DbCommand st,object value,int index,ISessionImplementor session, CancellationToken cancellationToken)
+		public override Task NullSafeSetAsync(DbCommand st, object value, int index, ISessionImplementor session, CancellationToken cancellationToken)
 		{
 			if (cancellationToken.IsCancellationRequested)
 			{
 				return Task.FromCanceled<object>(cancellationToken);
 			}
-			return baseType.NullSafeSetAsync(st, value == null ? null : keys[(string)value], index, session, cancellationToken);
+			try
+			{
+				// "_keys?[(string) value]" is valid code provided "_keys[(string) value]" can never yield null. It is the
+				// case because we use a dictionary interface which throws in case of missing key, and because it is not
+				// possible to have a value associated to a null key since generic dictionaries do not support null keys.
+				var key = value == null ? null : _keys?[(string) value] ?? value;
+
+				return _baseType.NullSafeSetAsync(st, key, index, session, cancellationToken);
+			}
+			catch (Exception ex)
+			{
+				return Task.FromException<object>(ex);
+			}
 		}
 
 		public override async Task<bool> IsDirtyAsync(object old, object current, bool[] checkable, ISessionImplementor session, CancellationToken cancellationToken)
diff --git a/src/NHibernate/Hql/Ast/ANTLR/Tree/BinaryLogicOperatorNode.cs b/src/NHibernate/Hql/Ast/ANTLR/Tree/BinaryLogicOperatorNode.cs
@@ -276,19 +276,19 @@ private void ProcessMetaTypeDiscriminatorIfNecessary(IASTNode lhs, IASTNode rhs)
 				return;
 			}
 
-			if (rhsNode is IdentNode && lhsNode.DataType is IMetaType lhsNodeMetaType)
+			if (rhsNode is IdentNode && lhsNode.DataType is MetaType lhsNodeMetaType)
 			{
 				EvaluateType(rhsNode, lhsNodeMetaType);
 				return;
 			}
 
-			if (lhsNode is IdentNode && rhsNode.DataType is IMetaType rhsNodeMetaType)
+			if (lhsNode is IdentNode && rhsNode.DataType is MetaType rhsNodeMetaType)
 			{
 				EvaluateType(lhsNode, rhsNodeMetaType);
 			}
 		}
 
-		private void EvaluateType(SqlNode node, IMetaType metaType)
+		private void EvaluateType(SqlNode node, MetaType metaType)
 		{
 			var sessionFactory = SessionFactoryHelper.Factory;
 
diff --git a/src/NHibernate/Mapping/Any.cs b/src/NHibernate/Mapping/Any.cs
@@ -19,6 +19,7 @@ public class Any : SimpleValue
 
 		public Any(Table table) : base(table)
 		{
+			_type = GetLazyType();
 		}
 
 		/// <summary>
@@ -30,29 +31,45 @@ public virtual string IdentifierTypeName
 			set { identifierTypeName = value; }
 		}
 
-		private IType type;
-		public override IType Type
+		private Lazy<IType> GetLazyType()
 		{
-			get
-			{
-				if (type == null)
+			return new Lazy<IType>(
+				() =>
 				{
-					type =
-						new AnyType(
-							metaValues == null
-							? ("class".Equals(metaTypeName) ? new ClassMetaType(): TypeFactory.HeuristicType(metaTypeName))
-								: new MetaType(metaValues, TypeFactory.HeuristicType(metaTypeName)),
-							TypeFactory.HeuristicType(identifierTypeName));
-				}
-				return type;
-			}
+					var identifierType = TypeFactory.HeuristicType(identifierTypeName);
+					if (identifierType == null)
+						throw new MappingException($"Identifier type '{identifierTypeName}' is invalid");
+
+					var hasMetaValues = metaValues != null && metaValues.Count > 0;
+
+					var metaType = !hasMetaValues && "class" == metaTypeName
+						? NHibernateUtil.String
+						: TypeFactory.HeuristicType(metaTypeName);
+
+					if (metaType == null)
+						throw new MappingException($"Meta type '{metaTypeName}' is invalid");
+
+					if (!hasMetaValues && metaType.ReturnedClass != typeof(string))
+						throw new MappingException(
+							$"Using a non-string meta type ('{metaTypeName}') without providing meta values is invalid");
+
+					return new AnyType(
+						new MetaType(metaValues, metaType),
+						identifierType);
+				});
 		}
 
+		// Types may be used by many threads, we must use a thread safe lazy initialization.
+		// (Or we should build this class in another way, but this would likely be a breaking change.)
+		private Lazy<IType> _type;
+
+		public override IType Type => _type.Value;
+
 		public void ResetCachedType()
 		{
 			// this is required if the user is programatically modifying the Any instance
 			// and need to reset the cached type instance;
-			type = null;
+			_type = GetLazyType();
 		}
 
 		public override void SetTypeUsingReflection(string className, string propertyName, string access)
diff --git a/src/NHibernate/NHibernateUtil.cs b/src/NHibernate/NHibernateUtil.cs
@@ -268,8 +268,15 @@ public static IType GuessType(System.Type type)
 		/// NHibernate class meta type for association of kind <code>any</code>.
 		/// </summary>
 		/// <seealso cref="AnyType"/>
+		[Obsolete("Use MetaType without meta-values instead.")]
 		public static readonly ClassMetaType ClassMetaType = new ClassMetaType();
 
+		/// <summary>
+		/// NHibernate meta type for association of kind <code>any</code> without meta-values.
+		/// </summary>
+		/// <seealso cref="AnyType"/>
+		public static readonly MetaType MetaType = new MetaType(null, String);
+
 		/// <summary>
 		/// NHibernate serializable type
 		/// </summary>
diff --git a/src/NHibernate/Type/AnyType.cs b/src/NHibernate/Type/AnyType.cs
@@ -46,20 +46,22 @@ public partial class AnyType : AbstractType, IAbstractComponentType, IAssociatio
 		private readonly IType identifierType;
 		private readonly IType metaType;
 
-		/// <summary>
-		/// 
-		/// </summary>
-		/// <param name="metaType"></param>
-		/// <param name="identifierType"></param>
+		private static readonly INHibernateLogger Log = NHibernateLogger.For(typeof(AnyType));
+
 		internal AnyType(IType metaType, IType identifierType)
 		{
-			this.identifierType = identifierType;
-			this.metaType = metaType;
+			this.identifierType = identifierType ?? throw new ArgumentNullException(nameof(identifierType));
+			this.metaType = metaType ?? throw new ArgumentNullException(nameof(metaType));
+
+			if (!(metaType is MetaType))
+			{
+				Log.Warn("Using AnyType with a meta type which is not a MetaType is obsolete and may cause" +
+				         "querying issues.");
+			}
 		}
 
-		/// <summary></summary>
 		internal AnyType()
-			: this(NHibernateUtil.String, NHibernateUtil.Serializable)
+			: this(NHibernateUtil.MetaType, NHibernateUtil.Serializable)
 		{
 		}
 
diff --git a/src/NHibernate/Type/ClassMetaType.cs b/src/NHibernate/Type/ClassMetaType.cs
@@ -12,7 +12,8 @@ namespace NHibernate.Type
 	/// It work like a MetaType where the key is the entity-name it self
 	/// </remarks>
 	[Serializable]
-	public partial class ClassMetaType : AbstractType, IMetaType
+	[Obsolete("Use MetaType without meta-values instead.")]
+	public partial class ClassMetaType : AbstractType
 	{
 		public override SqlType[] SqlTypes(IMapping mapping)
 		{
@@ -100,10 +101,5 @@ public override bool[] ToColumnNullness(object value, IMapping mapping)
 		{
 			return NHibernateUtil.String.ToColumnNullness(value, mapping);
 		}
-
-		string IMetaType.GetMetaValue(string className, Dialect.Dialect dialect)
-		{
-			return NHibernateUtil.String.ObjectToSQLString(className, dialect);
-		}
 	}
 }
diff --git a/src/NHibernate/Type/IMetaType.cs b/src/NHibernate/Type/IMetaType.cs
diff --git a/src/NHibernate/Type/MetaType.cs b/src/NHibernate/Type/MetaType.cs

Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@`
`2`	`2`
`3`	`3`	`namespace NHibernate.Test.NHSpecificTest.GH1774.Implicit`
`4`	`4`	`{`
`5`		`- [TestFixture, Ignore("Not fixed yet")]`
	`5`	`+ [TestFixture]`
`6`	`6`	`public class ImplicitMetaTypeFixture : FixtureBase`
`7`	`7`	`{`
`8`	`8`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ namespace NHibernate.Type`
`17`	`17`	`{`
`18`	`18`	`using System.Threading.Tasks;`
`19`	`19`	`using System.Threading;`
`20`		`- public partial class ClassMetaType : AbstractType, IMetaType`
	`20`	`+ public partial class ClassMetaType : AbstractType`
`21`	`21`	`{`
`22`	`22`
`23`	`23`	`public override Task<object> NullSafeGetAsync(DbDataReader rs, string[] names, ISessionImplementor session, object owner, CancellationToken cancellationToken)`
Original file line number	Diff line number	Diff line change
`@@ -13,27 +13,24 @@`
`13`	`13`	`using System.Data.Common;`
`14`	`14`	`using NHibernate.Engine;`
`15`	`15`	`using NHibernate.SqlTypes;`
`16`		`-using NHibernate.Util;`
`17`	`16`
`18`	`17`	`namespace NHibernate.Type`
`19`	`18`	`{`
`20`	`19`	`using System.Threading.Tasks;`
`21`	`20`	`using System.Threading;`
`22`		`- public partial class MetaType : AbstractType, IMetaType`
	`21`	`+ public partial class MetaType : AbstractType`
`23`	`22`	`{`
`24`	`23`
`25`	`24`	`public override async Task<object> NullSafeGetAsync(DbDataReader rs, string[] names, ISessionImplementor session, object owner, CancellationToken cancellationToken)`
`26`	`25`	`{`
`27`	`26`	`cancellationToken.ThrowIfCancellationRequested();`
`28`		`- object key = await (baseType.NullSafeGetAsync(rs, names, session, owner, cancellationToken)).ConfigureAwait(false);`
`29`		`- return key == null ? null : values[key];`
	`27`	`+ return GetValueForKey(await (_baseType.NullSafeGetAsync(rs, names, session, owner, cancellationToken)).ConfigureAwait(false));`
`30`	`28`	`}`
`31`	`29`
`32`		`- public override async Task<object> NullSafeGetAsync(DbDataReader rs,string name,ISessionImplementor session,object owner, CancellationToken cancellationToken)`
	`30`	`+ public override async Task<object> NullSafeGetAsync(DbDataReader rs, string name, ISessionImplementor session, object owner, CancellationToken cancellationToken)`
`33`	`31`	`{`
`34`	`32`	`cancellationToken.ThrowIfCancellationRequested();`
`35`		`- object key = await (baseType.NullSafeGetAsync(rs, name, session, owner, cancellationToken)).ConfigureAwait(false);`
`36`		`- return key == null ? null : values[key];`
	`33`	`+ return GetValueForKey(await (_baseType.NullSafeGetAsync(rs, name, session, owner, cancellationToken)).ConfigureAwait(false));`
`37`	`34`	`}`
`38`	`35`
`39`	`36`	`public override Task NullSafeSetAsync(DbCommand st, object value, int index, bool[] settable, ISessionImplementor session, CancellationToken cancellationToken)`
`@@ -53,13 +50,25 @@ public override Task NullSafeSetAsync(DbCommand st, object value, int index, boo`
`53`	`50`	`}`
`54`	`51`	`}`
`55`	`52`
`56`		`- public override Task NullSafeSetAsync(DbCommand st,object value,int index,ISessionImplementor session, CancellationToken cancellationToken)`
	`53`	`+ public override Task NullSafeSetAsync(DbCommand st, object value, int index, ISessionImplementor session, CancellationToken cancellationToken)`
`57`	`54`	`{`
`58`	`55`	`if (cancellationToken.IsCancellationRequested)`
`59`	`56`	`{`
`60`	`57`	`return Task.FromCanceled<object>(cancellationToken);`
`61`	`58`	`}`
`62`		`- return baseType.NullSafeSetAsync(st, value == null ? null : keys[(string)value], index, session, cancellationToken);`
	`59`	`+ try`
	`60`	`+ {`
	`61`	`+ // "_keys?[(string) value]" is valid code provided "_keys[(string) value]" can never yield null. It is the`
	`62`	`+ // case because we use a dictionary interface which throws in case of missing key, and because it is not`
	`63`	`+ // possible to have a value associated to a null key since generic dictionaries do not support null keys.`
	`64`	`+ var key = value == null ? null : _keys?[(string) value] ?? value;`
	`65`	`+`
	`66`	`+ return _baseType.NullSafeSetAsync(st, key, index, session, cancellationToken);`
	`67`	`+ }`
	`68`	`+ catch (Exception ex)`
	`69`	`+ {`
	`70`	`+ return Task.FromException<object>(ex);`
	`71`	`+ }`
`63`	`72`	`}`
`64`	`73`
`65`	`74`	`public override async Task<bool> IsDirtyAsync(object old, object current, bool[] checkable, ISessionImplementor session, CancellationToken cancellationToken)`
Original file line number	Diff line number	Diff line change
`@@ -276,19 +276,19 @@ private void ProcessMetaTypeDiscriminatorIfNecessary(IASTNode lhs, IASTNode rhs)`
`276`	`276`	`return;`
`277`	`277`	`}`
`278`	`278`
`279`		`- if (rhsNode is IdentNode && lhsNode.DataType is IMetaType lhsNodeMetaType)`
	`279`	`+ if (rhsNode is IdentNode && lhsNode.DataType is MetaType lhsNodeMetaType)`
`280`	`280`	`{`
`281`	`281`	`EvaluateType(rhsNode, lhsNodeMetaType);`
`282`	`282`	`return;`
`283`	`283`	`}`
`284`	`284`
`285`		`- if (lhsNode is IdentNode && rhsNode.DataType is IMetaType rhsNodeMetaType)`
	`285`	`+ if (lhsNode is IdentNode && rhsNode.DataType is MetaType rhsNodeMetaType)`
`286`	`286`	`{`
`287`	`287`	`EvaluateType(lhsNode, rhsNodeMetaType);`
`288`	`288`	`}`
`289`	`289`	`}`
`290`	`290`
`291`		`- private void EvaluateType(SqlNode node, IMetaType metaType)`
	`291`	`+ private void EvaluateType(SqlNode node, MetaType metaType)`
`292`	`292`	`{`
`293`	`293`	`var sessionFactory = SessionFactoryHelper.Factory;`
`294`	`294`