Generate stable sql objects names

Fix #1769

Author: fredericDelaporte

src/NHibernate.Test/MappingTest/TableFixture.cs

@@ -1,5 +1,3 @@
-using System.Linq;
-using System.Threading;
 using NHibernate.Dialect;
 using NHibernate.Mapping;
 using NUnit.Framework;
@@ -61,5 +59,14 @@ public void SchemaNameQuoted()
 
 			Assert.AreEqual("[schema].name", tbl.GetQualifiedName(dialect));
 		}
+
+		[Test]
+		public void NameIsStable()
+		{
+			var tbl = new Table { Name = "name" };
+			Assert.That(
+				Constraint.GenerateName("FK_", tbl, null, new[] {new Column("col1"), new Column("col2")}),
+				Is.EqualTo("FK_IHNJ2ONUQL23X2DYGJ2YBBV3F7A"));
+		}
 	}
 }

src/NHibernate.Test/NHSpecificTest/NH1399/Fixture.cs

@@ -1,9 +1,10 @@
+using System;
 using NHibernate.Mapping;
 using NUnit.Framework;
 
 namespace NHibernate.Test.NHSpecificTest.NH1399
 {
-	[TestFixture]
+	[TestFixture, Obsolete]
 	public class Fixture
 	{
 		[Test]
@@ -42,4 +43,4 @@ public void UsingTwoInstancesWithSameValuesTheFkNameIsTheSame()
 			Assert.That(t2Fk_, Is.EqualTo(t2Fk));
 		}
 	}
-}
+}

src/NHibernate/Cfg/Configuration.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
-using System.Configuration;
 using System.Diagnostics;
 using System.IO;
 using System.Linq;
@@ -1191,6 +1190,13 @@ private void SecondPassCompileForeignKeys(Table table, ISet<ForeignKey> done)
 						try
 						{
 							fk.AddReferencedTable(referencedClass);
+
+							if (string.IsNullOrEmpty(fk.Name))
+							{
+								fk.Name = Constraint.GenerateName(
+									fk.GeneratedConstraintNamePrefix, table, fk.ReferencedTable, fk.Columns);
+							}
+
 							fk.AlignColumns();
 						}
 						catch (MappingException me)

src/NHibernate/Mapping/Constraint.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Security.Cryptography;
 using System.Text;
 using NHibernate.Engine;
 using NHibernate.Util;
@@ -38,6 +39,142 @@ public IEnumerable<Column> ColumnIterator
 			get { return columns; }
 		}
 
+		/// <summary>
+		/// Generate a name hopefully unique using the table and column names.
+		/// Static so the name can be generated prior to creating the Constraint.
+		/// They're cached, keyed by name, in multiple locations.
+		/// </summary>
+		/// <param name="prefix">A name prefix for the generated name.</param>
+		/// <param name="table">The table for which the name is generated.</param>
+		/// <param name="referencedTable">The referenced table, if any.</param>
+		/// <param name="columns">The columns for which the name is generated.</param>
+		/// <returns>The generated name.</returns>
+		/// <remarks>Hybrid of Hibernate <c>Constraint.generateName</c> and
+		/// <c>NamingHelper.generateHashedFkName</c>.</remarks>
+		public static string GenerateName(
+			string prefix, Table table, Table referencedTable, IEnumerable<Column> columns)
+		{
+			// Use a concatenation that guarantees uniqueness, even if identical names
+			// exist between all table and column identifiers.
+			var sb = new StringBuilder("table`" + table.Name + "`");
+			if (referencedTable != null)
+				sb.Append("references`" + referencedTable.Name + "`");
+
+			// Ensure a consistent ordering of columns, regardless of the order
+			// they were bound.
+			// Clone the list, as sometimes a set of order-dependent Column
+			// bindings are given.
+			var alphabeticalColumns = new List<Column>(columns);
+			alphabeticalColumns.Sort(ColumnComparator.Instance);
+			foreach (var column in alphabeticalColumns)
+			{
+				var columnName = column == null ? "" : column.Name;
+				sb.Append("column`").Append(columnName).Append("`");
+			}
+			// Hash the generated name for avoiding collisions with user choosen names.
+			// This is not 100% reliable, as hashing may still have a chance of generating
+			// collisions.
+			var name = prefix + HashName(sb.ToString());
+
+			// Hibernate uses an algorithm yielding names shorter than 30 characters. But we cannot
+			// use it (see HashName). And also we have DB limited to even less (Informix)...
+			if (name.Length > 30)
+			{
+				// This, of course, increases the collision risk.
+				name = name.Substring(0, 30);
+			}
+
+			return name;
+		}
+
+		#region Name generation support methods
+
+		/// <summary>
+		/// Hash a constraint name. Convert the hash digest to base 32
+		/// (full alphanumeric) for shortening the hash string representation
+		/// while keeping it suitable for db names.
+		/// </summary>
+		/// <param name="name">The name to be hashed.</param>
+		/// <returns>The hased name.</returns>
+		private static string HashName(string name)
+		{
+			// Hibernate uses MD5, but with .Net this would throw on FIPS enabled machine.
+			// As a consequence generated names will be quite longer.
+			using (var hasher = SHA256.Create())
+			{
+				var hash = hasher.ComputeHash(Encoding.UTF8.GetBytes(name));
+				// Converting to base 32 for shortening the name.
+				// Hibernate uses base 35, but we do not have a native implementation
+				// in .Net, and base 32 is easier to implement.
+				return ToBase32String(hash);
+			}
+		}
+
+		// Adapted from https://stackoverflow.com/a/7135008/1178314
+		// Changed for not padding with "="
+		private static string ToBase32String(byte[] input)
+		{
+			if (input == null || input.Length == 0)
+			{
+				throw new ArgumentNullException(nameof(input));
+			}
+
+			var charCount = (int) Math.Ceiling(input.Length / 5d) * 8;
+			var result = new StringBuilder(charCount);
+
+			byte nextChar = 0, bitsRemaining = 5;
+
+			foreach (var b in input)
+			{
+				nextChar = (byte)(nextChar | (b >> (8 - bitsRemaining)));
+				result.Append(ValueToChar(nextChar));
+
+				if (bitsRemaining < 4)
+				{
+					nextChar = (byte)((b >> (3 - bitsRemaining)) & 31);
+					result.Append(ValueToChar(nextChar));
+					bitsRemaining += 5;
+				}
+
+				bitsRemaining -= 3;
+				nextChar = (byte)((b << bitsRemaining) & 31);
+			}
+
+			// If we didn't end with a full char
+			if (result.Length != charCount)
+			{
+				result.Append(ValueToChar(nextChar));
+			}
+
+			return result.ToString();
+		}
+
+		private static char ValueToChar(byte b)
+		{
+			if (b < 26)
+			{
+				return (char)(b + 65);
+			}
+
+			if (b < 32)
+			{
+				return (char)(b + 24);
+			}
+
+			throw new ArgumentException("Byte is not a value Base32 value.", "b");
+		}
+
+		private class ColumnComparator : IComparer<Column>
+		{
+			public static readonly ColumnComparator Instance = new ColumnComparator();
+
+			public int Compare(Column col1, Column col2) {
+				return StringComparer.Ordinal.Compare(col1?.Name, col2?.Name);
+			}
+		}
+
+		#endregion
+
 		/// <summary>
 		/// Adds the <see cref="Column"/> to the <see cref="ICollection"/> of 
 		/// Columns that are part of the constraint.

src/NHibernate/Mapping/DenormalizedTable.cs

@@ -1,7 +1,7 @@
 using System;
-using System.Collections;
 using NHibernate.Util;
 using System.Collections.Generic;
+using System.Linq;
 
 namespace NHibernate.Mapping
 {
@@ -56,21 +56,19 @@ public override IEnumerable<Index> IndexIterator
 		public override void CreateForeignKeys()
 		{
 			includedTable.CreateForeignKeys();
-			IEnumerable includedFks = includedTable.ForeignKeyIterator;
-			foreach (ForeignKey fk in includedFks)
+			var includedFks = includedTable.ForeignKeyIterator;
+			foreach (var fk in includedFks)
 			{
-				// NH Different behaviour (fk name)
-				CreateForeignKey(GetForeignKeyName(fk), fk.Columns, fk.ReferencedEntityName);
+				CreateForeignKey(
+					Constraint.GenerateName(
+						fk.GeneratedConstraintNamePrefix,
+						this,
+						null,
+						fk.Columns),
+					fk.Columns, fk.ReferencedEntityName);
 			}
 		}
 
-		private string GetForeignKeyName(ForeignKey fk)
-		{
-			// (the FKName length, of H3.2 implementation, may be too long for some RDBMS so we implement something different) 
-			int hash = fk.Name.GetHashCode() ^ Name.GetHashCode();
-			return string.Format("KF{0}", hash.ToString("X"));
-		}
-
 		public override Column GetColumn(Column column)
 		{
 			Column superColumn = base.GetColumn(column);

src/NHibernate/Mapping/ForeignKey.cs

@@ -1,4 +1,3 @@
-using System.Collections;
 using System.Collections.Generic;
 using System.Text;
 using NHibernate.Util;
@@ -233,5 +232,7 @@ public bool IsReferenceToPrimaryKey
 		{
 			get { return referencedColumns.Count == 0; }
 		}
+
+		public string GeneratedConstraintNamePrefix => "FK_";
 	}
 }

src/NHibernate/Mapping/Table.cs

@@ -808,15 +808,9 @@ public virtual ForeignKey CreateForeignKey(string keyName, IEnumerable<Column> k
 			if (fk == null)
 			{
 				fk = new ForeignKey();
-				if (!string.IsNullOrEmpty(keyName))
-				{
-					fk.Name = keyName;
-				}
-				else
-				{
-					fk.Name = "FK" + UniqueColumnString(kCols, referencedEntityName);
-					//TODO: add referencedClass to disambiguate to FKs on the same columns, pointing to different tables
-				}
+				// NOTE : if the name is null, we will generate an implicit name during second pass processing
+				// after we know the referenced table name (which might not be resolved yet).
+				fk.Name = keyName;
 				fk.Table = this;
 				foreignKeys.Add(key, fk);
 				fk.ReferencedEntityName = referencedEntityName;
@@ -837,8 +831,8 @@ public virtual ForeignKey CreateForeignKey(string keyName, IEnumerable<Column> k
 
 		public virtual UniqueKey CreateUniqueKey(IList<Column> keyColumns)
 		{
-			string keyName = "UK" + UniqueColumnString(keyColumns);
-			UniqueKey uk = GetOrCreateUniqueKey(keyName);
+			var keyName = Constraint.GenerateName( "UK_", this, null, keyColumns);
+			var uk = GetOrCreateUniqueKey(keyName);
 			uk.AddColumns(keyColumns);
 			return uk;
 		}
@@ -851,11 +845,14 @@ public virtual UniqueKey CreateUniqueKey(IList<Column> keyColumns)
 		/// <returns>
 		/// An unique string for the <see cref="Column"/> objects.
 		/// </returns>
+		// Since v5.2
+		[Obsolete("Use Constraint.GenerateName instead.")]
 		public string UniqueColumnString(IEnumerable uniqueColumns)
 		{
 			return UniqueColumnString(uniqueColumns, null);
 		}
 
+		[Obsolete("Use Constraint.GenerateName instead.")]
 		public string UniqueColumnString(IEnumerable iterator, string referencedEntityName)
 		{
 			// NH Different implementation (NH-1399)