Merge pull request #121 from DataObjects-NET/silent-table-cleanup-issue

Silent table cleanup issue

Author: alex-kulakov

Orm/Xtensive.Orm.Tests/Upgrade/UpgradeToNewHierarchyThatInheritsStructureTest.cs

@@ -1,4 +1,4 @@
-// Copyright (C) 2010-2020 Xtensive LLC.
+// Copyright (C) 2010-2021 Xtensive LLC.
 // This code is distributed under MIT license terms.
 // See the License.txt file in the project root for more information.
 // Created by: Alex Yakunin
@@ -124,6 +124,12 @@ public IEnumerable<TClass> GetClasses()
       return classified.Keys;
     }
 
+    public int GetItemCount(TClass @class)
+    {
+      var items = classified.GetValueOrDefault(@class);
+      return items != null ? items.Count : 0;
+    }
+
     #region IEnumerable<...> members
 
     IEnumerator IEnumerable.GetEnumerator()

Orm/Xtensive.Orm/Collections/ClassifiedCollection.cs

@@ -1,4 +1,4 @@
-// Copyright (C) 2003-2010 Xtensive LLC.
+// Copyright (C) 2010-2021 Xtensive LLC.
 // All rights reserved.
 // For conditions of distribution and use, see license.
 // Created by: Alex Yakunin
@@ -29,6 +29,11 @@ public IEnumerable<TItem> GetItems<TClass>()
       return GetItems(typeof (TClass));
     }
 
+    public int GetItemCount<TClass>()
+    {
+      return GetItemCount(typeof(TClass));
+    }
+
     // Constructors
 
     /// <inheritdoc/>

Orm/Xtensive.Orm/Collections/TypeClassifier.cs

@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2020 Xtensive LLC.
+// Copyright (C) 2007-2021 Xtensive LLC.
 // This code is distributed under MIT license terms.
 // See the License.txt file in the project root for more information.
 // Created by: Anton U. Rogozhin
@@ -207,5 +207,33 @@ public static IEnumerable<TSource> ReverseList<TSource>(this IList<TSource> sour
       for (var i = source.Count - 1; i >= 0; i--)
         yield return source[i];
     }
+
+    /// <summary>
+    /// Projects each element of a sequence into two elements of new form and adds it to the first or the second array respectively.
+    /// </summary>
+    /// <typeparam name="TSource">Type of source sequence.</typeparam>
+    /// <typeparam name="TFirst">Type of elements of first result array.</typeparam>
+    /// <typeparam name="TSecond">Type of elements of first result array.</typeparam>
+    /// <param name="source">A collection of values to invoke a transform functions on.</param>
+    /// <param name="firstArraySelector">A transform function to apply to each element to get element of the first array.</param>
+    /// <param name="secondArraySelector">A transform function to apply to each element to get element of the second array.</param>
+    /// <returns>Pair of two arrays.</returns>
+    internal static Pair<TFirst[], TSecond[]> SelectToArrays<TSource, TFirst,TSecond>(
+      this ICollection<TSource> source, Func<TSource, TFirst> firstArraySelector, Func<TSource, TSecond> secondArraySelector)
+    {
+      ArgumentValidator.EnsureArgumentNotNull(source, nameof(source));
+      ArgumentValidator.EnsureArgumentNotNull(firstArraySelector, nameof(firstArraySelector));
+      ArgumentValidator.EnsureArgumentNotNull(secondArraySelector, nameof(secondArraySelector));
+
+      var first = new TFirst[source.Count];
+      var second = new TSecond[source.Count];
+      var index = 0;
+      foreach (var item in source) {
+        first[index] = firstArraySelector(item);
+        second[index] = secondArraySelector(item);
+        index++;
+      }
+      return new Pair<TFirst[], TSecond[]>(first, second);
+    }
   }
 }

Orm/Xtensive.Orm/Core/Extensions/CollectionExtensions.cs

@@ -291,6 +291,104 @@ public static List<TItem> ToList<TItem>(this IEnumerable<TItem> source, int capa
       return result;
     }
 
+    /// <summary>
+    /// Creates a <see cref="Dictionary{TKey, TValue}"/> with pre-defined capacity from an <see cref="IEnumerable{T}"/>
+    /// according to a specified key selector function.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the elements of source.</typeparam>
+    /// <typeparam name="TKey">The type of the key elements.</typeparam>
+    /// <param name="source">A sequence to create a <see cref="Dictionary{TKey, TValue}"/> from.</param>
+    /// <param name="keySelector">A function to extract a key from each element.</param>
+    /// <param name="capacity">Initial dictionary capacity.</param>
+    /// <returns>A <see cref="Dictionary{TKey, TValue}"/> that contains keys and values.</returns>
+    public static Dictionary<TKey, TSource> ToDictionary<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, int capacity)
+    {
+      return ToDictionary<TSource, TKey, TSource>(source, keySelector, InstanceSelector, capacity);
+
+      static TSource InstanceSelector(TSource x)
+      {
+        return x;
+      }
+    }
+
+    /// <summary>
+    /// Creates a <see cref="Dictionary{TKey, TValue}"/> with pre-defined capacity from an <see cref="IEnumerable{T}"/>
+    /// according to a specified key selector function.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the elements of source.</typeparam>
+    /// <typeparam name="TKey">The type of the key elements.</typeparam>
+    /// <param name="source">A sequence to create a <see cref="Dictionary{TKey, TValue}"/> from.</param>
+    /// <param name="keySelector">A function to extract a key from each element.</param>
+    /// <param name="comparer">An <see cref="IEqualityComparer{T}"/> to compare keys.</param>
+    /// <param name="capacity">Initial dictionary capacity.</param>
+    /// <returns>A <see cref="Dictionary{TKey, TValue}"/> that contains keys and values.</returns>
+    public static Dictionary<TKey, TSource> ToDictionary<TSource, TKey>(
+      this IEnumerable<TSource> source,
+      Func<TSource, TKey> keySelector,
+      IEqualityComparer<TKey> comparer,
+      int capacity)
+    {
+      return ToDictionary<TSource, TKey, TSource>(source, keySelector, InstanceSelector, comparer, capacity);
+
+      static TSource InstanceSelector(TSource x)
+      {
+        return x;
+      }
+    }
+
+    /// <summary>
+    /// Creates a <see cref="Dictionary{TKey, TValue}"/> with pre-defined capacity from an <see cref="IEnumerable{T}"/>
+    /// according to a specified key selector function.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the elements of source.</typeparam>
+    /// <typeparam name="TKey">The type of the key elements.</typeparam>
+    /// <param name="source">A sequence to create a <see cref="Dictionary{TKey, TValue}"/> from.</param>
+    /// <param name="keySelector">A function to extract a key from each element.</param>
+    /// <param name="elementSelector">A funtion to extract a value from each element.</param>
+    /// <param name="capacity">Initial dictionary capacity.</param>
+    /// <returns>A <see cref="Dictionary{TKey, TValue}"/> that contains keys and values.</returns>
+    public static Dictionary<TKey, TValue> ToDictionary<TSource, TKey, TValue>(
+      this IEnumerable<TSource> source,
+      Func<TSource, TKey> keySelector,
+      Func<TSource, TValue> elementSelector,
+      int capacity)
+    {
+      return ToDictionary(source, keySelector, elementSelector, null, capacity);
+    }
+
+    /// <summary>
+    /// Creates a <see cref="Dictionary{TKey, TValue}"/> with pre-defined capacity from an <see cref="IEnumerable{T}"/>
+    /// according to a specified key selector function.
+    /// </summary>
+    /// <typeparam name="TSource">The type of the elements of source.</typeparam>
+    /// <typeparam name="TKey">The type of the key elements.</typeparam>
+    /// <param name="source">A sequence to create a <see cref="Dictionary{TKey, TValue}"/> from.</param>
+    /// <param name="keySelector">A function to extract a key from each element.</param>
+    /// <param name="elementSelector">A funtion to extract a value from each element.</param>
+    /// <param name="comparer">An <see cref="IEqualityComparer{T}"/> to compare keys.</param>
+    /// <param name="capacity">Initial dictionary capacity.</param>
+    /// <returns>A <see cref="Dictionary{TKey, TValue}"/> that contains keys and values.</returns>
+    public static Dictionary<TKey, TValue> ToDictionary<TSource, TKey, TValue>(
+      this IEnumerable<TSource> source,
+      Func<TSource, TKey> keySelector,
+      Func<TSource, TValue> elementSelector,
+      IEqualityComparer<TKey> equalityComparer,
+      int capacity)
+    {
+      ArgumentValidator.EnsureArgumentNotNull(source, nameof(source));
+      ArgumentValidator.EnsureArgumentNotNull(keySelector, nameof(keySelector));
+      ArgumentValidator.EnsureArgumentNotNull(elementSelector, nameof(elementSelector));
+      ArgumentValidator.EnsureArgumentIsGreaterThanOrEqual(capacity, 0, nameof(capacity));
+
+      var dictionary = equalityComparer != null
+        ? new Dictionary<TKey, TValue>(capacity, equalityComparer)
+        : new Dictionary<TKey, TValue>(capacity);
+      foreach (var item in source) {
+        dictionary.Add(keySelector(item), elementSelector(item));
+      }
+      return dictionary;
+    }
+
     /// <summary>
     /// Gets the items from the segment.
     /// </summary>

Orm/Xtensive.Orm/Core/Extensions/EnumerableExtensions.cs

@@ -1,4 +1,4 @@
-// Copyright (C) 2009-2020 Xtensive LLC.
+// Copyright (C) 2009-2021 Xtensive LLC.
 // This code is distributed under MIT license terms.
 // See the License.txt file in the project root for more information.
 // Created by: Alex Yakunin
@@ -228,6 +228,10 @@ protected virtual MovementInfo BuildMovementInfo(Node source, Node target)
         return movementInfo;
       }
 
+      var recreateHint = Hints.GetHint<RecreateTableHint>(source);
+      if (recreateHint != null) {
+        movementInfo |= MovementInfo.Removed | MovementInfo.Created;// recreated;
+      }
       var sc = StringComparer.OrdinalIgnoreCase;
 
       // both source!=null && target!=null
@@ -611,9 +615,9 @@ protected bool HasDataChangeHint(Node source)
         return false;
 
       return 
-        Hints.GetHints<CopyDataHint>(source).Any()
-        || Hints.GetHints<DeleteDataHint>(source).Any()
-        || Hints.GetHints<UpdateDataHint>(source).Any();
+        Hints.HasHints<CopyDataHint>(source)
+        || Hints.HasHints<DeleteDataHint>(source)
+        || Hints.HasHints<UpdateDataHint>(source);
     }
 
     /// <summary>

Orm/Xtensive.Orm/Modelling/Comparison/Comparer.cs

@@ -1,4 +1,4 @@
-// Copyright (C) 2003-2010 Xtensive LLC.
+// Copyright (C) 2009-2021 Xtensive LLC.
 // All rights reserved.
 // For conditions of distribution and use, see license.
 // Created by: Alex Yakunin
@@ -188,6 +188,17 @@ public bool HasHints(Node node)
       return nodeHintMap.Values.Count > 0;
     }
 
+    public bool HasHints<THint>(Node node)
+      where THint : Hint
+    {
+      ArgumentValidator.EnsureArgumentNotNull(node, "node");
+
+      if (!hintMap.TryGetValue(node, out var nodeHintMap)) {
+        hintMap.Add(node, nodeHintMap = new Dictionary<Type, object>());
+      }
+      return nodeHintMap.ContainsKey(typeof(THint));
+    }
+
     #region IEnumerable<...> methods
 
     /// <inheritdoc/>
@@ -247,4 +258,4 @@ private HintSet()
     {
     }
   }
-}
+}

Orm/Xtensive.Orm/Modelling/Comparison/Hints/HintSet.cs

@@ -0,0 +1,37 @@
+// Copyright (C) 2021 Xtensive LLC.
+// This code is distributed under MIT license terms.
+// See the License.txt file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Xtensive.Modelling.Comparison.Hints
+{
+  /// <summary>
+  /// Hints comparer that the table is recreated.
+  /// How to treat it is up to comparer.
+  /// </summary>
+  [Serializable]
+  public sealed class RecreateTableHint : Hint
+  {
+    /// <summary>
+    /// Path to the table.
+    /// </summary>
+    public string Path { get; private set; }
+
+    /// <inheritdoc/>
+    public override IEnumerable<HintTarget> GetTargets()
+    {
+      yield return new HintTarget(ModelType.Source, Path);
+      yield return new HintTarget(ModelType.Target, Path);
+    }
+
+    public override string ToString() => $"Recreate '{Path}'";
+
+    public RecreateTableHint(string path)
+    {
+      Path = path;
+    }
+  }
+}