Tuple transform refactoring

ChangeLog/7.3.0-Beta-1-dev.txt

@@ -2,6 +2,10 @@
 [main] Removed obsolete member Values of SqlInsert type
 [main] Removed obsolete methods GetSingleConstructor/GetSingleConstructorOrDefault of TypeHelper type
 [main] Removed obsolete constant WellKnown.MaxNumberOfConditions, use DefaultMaxNumberOfConditions instead
+[main] Tuple transformation heavily refactored, many types from Xtensive.Tuples.Transform removed, renamed or turned to internal
+[main] Collection FixedList3 is removed
+[main] Xtensive.Orm.Rse.Providers.Provider descendants no longer build RecordSetHeader on initialization via virtual method
+[main] Many compilable providers build headers more easily with static methods
 [firebird] Switch to .NET8/.NET10-only support, nuget packages actualized
 [firebird] Support for Firebird 2.5 ended due to end-of-life state
 [mysql] Switch to .NET8/.NET10-only support, nuget packages actualized

Directory.Build.props

@@ -122,7 +122,7 @@
     <IncludeSymbols Condition="$(GeneratePackageOnBuild) == 'true'">true</IncludeSymbols>
     <SymbolPackageFormat>snupkg</SymbolPackageFormat>
     <EmbedUntrackedSources>true</EmbedUntrackedSources>
-    <ContinuousIntegrationBuild>true</ContinuousIntegrationBuild>
+    <ContinuousIntegrationBuild>false</ContinuousIntegrationBuild>
   </PropertyGroup>
 
   <ItemGroup>

Extensions/Xtensive.Orm.Security/Cryptography/MD5HashingService.cs

@@ -5,7 +5,6 @@
 // Created:    2011.05.22
 
 using System.Security.Cryptography;
-using System.Text;
 using Xtensive.IoC;
 
 namespace Xtensive.Orm.Security.Cryptography

Orm/Xtensive.Orm.Sqlite/Sql.Drivers.Sqlite/ProviderInitializer.cs

@@ -54,12 +54,11 @@ private static Stream GetLibraryStream()
     private static string GetLibraryHash()
     {
       using (var hashProvider = SHA1.Create()) {
-        //hashProvider.Initialize();
-        ReadOnlySpan<byte> hashRaw;
-        using (var stream = GetLibraryStream()) {
-          hashRaw = hashProvider.ComputeHash(stream);
-        }
-        return new StringBuilder().AppendHexArray(hashRaw[..8]).ToString();
+        hashProvider.Initialize();
+        using (var stream = GetLibraryStream())
+          hashProvider.ComputeHash(stream);
+        var hash = hashProvider.Hash.Take(8).ToArray();
+        return new StringBuilder().AppendHexArray(hash).ToString();
       }
     }
 

Orm/Xtensive.Orm.Tests.Core/Tuples/Transform/MapTransformTest.cs

@@ -16,9 +16,9 @@ public class MapTransformTest
   {
     public void MainTest()
     {
-      Xtensive.Tuples.Tuple source = Tuple.Create(1);
-      MapTransform transform = new MapTransform(true, TupleDescriptor.Create<byte, int, string>(), new[] {-1, 0});
-      Xtensive.Tuples.Tuple result = transform.Apply(TupleTransformType.TransformedTuple, source);
+      var source = Tuple.Create(1);
+      var transform = new MapTransform(true, TupleDescriptor.Create<byte, int, string>(), new[] {-1, 0});
+      var result = transform.Apply(TupleTransformType.TransformedTuple, source);
       Assert.That(result.GetFieldState(0), Is.EqualTo(TupleFieldState.Default));
       Assert.That(result.GetFieldState(1), Is.EqualTo(TupleFieldState.Available));
       Assert.That(result.GetFieldState(2), Is.EqualTo(TupleFieldState.Default));

Orm/Xtensive.Orm.Tests.Core/Tuples/Transform/MergeTransformTest.cs

@@ -1,24 +1,21 @@
-// Copyright (C) 2003-2010 Xtensive LLC.
-// All rights reserved.
-// For conditions of distribution and use, see license.
+// Copyright (C) 2008-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
 // Created:    2008.06.05
 
 using System;
 using NUnit.Framework;
 using Xtensive.Comparison;
-using Xtensive.Core;
-using Xtensive.Tuples;
-using Xtensive.Orm.Tests;
 using Xtensive.Tuples.Transform;
-using Tuple = Xtensive.Tuples.Tuple;
 
 namespace Xtensive.Orm.Tests.Core.Tuples.Transform
 {
   [TestFixture]
   public class MergeTransformTest
   {
-    public const int IterationCount = 1000000;
+    private const int IterationCount = 1_000_000;
+    private const int MeasurementRuns = 5;
 
     [Test]
     public void BaseTest()
@@ -27,8 +24,8 @@ public void BaseTest()
       Xtensive.Tuples.Tuple t2 = Xtensive.Tuples.Tuple.Create(3, 4.0, "5");
       TestLog.Info($"Originals: {t1}, {t2}");
 
-      CombineTransform mt   = new CombineTransform(false, t1.Descriptor, t2.Descriptor);
-      CombineTransform mtro = new CombineTransform(true,  t1.Descriptor, t2.Descriptor);
+      ConcatTransform mt   = new ConcatTransform(false, t1.Descriptor, t2.Descriptor);
+      ConcatTransform mtro = new ConcatTransform(true,  t1.Descriptor, t2.Descriptor);
 
       Xtensive.Tuples.Tuple wt1 = mt.Apply(TupleTransformType.TransformedTuple, t1, t2);
       TestLog.Info($"Wrapper:   {wt1}");
@@ -57,34 +54,27 @@ public void BaseTest()
       AssertEx.Throws<NotSupportedException>(delegate {
         wtro.SetValue(2, 0);
       });
+    }
+
+    [Test]
+    public void ToStringTest()
+    {
+      Xtensive.Tuples.Tuple t1 = Xtensive.Tuples.Tuple.Create(1, "2");
+      Xtensive.Tuples.Tuple t2 = Xtensive.Tuples.Tuple.Create(3, 4.0, "5");
+
+      var ct = new ConcatTransform(false, t1.Descriptor, t2.Descriptor);
+      Assert.That(ct.ToString(), Is.EqualTo("ConcatTransform(TupleDescriptor(Int32, String) + TupleDescriptor(Int32, Double, String), r/w)"));
 
-      CombineTransform mt3 = new CombineTransform(false, t1.Descriptor, t1.Descriptor, t1.Descriptor);
-      Xtensive.Tuples.Tuple wt3 = mt3.Apply(TupleTransformType.TransformedTuple, t1, t1, t1);
-      TestLog.Info($"Wrapper:   {wt3}");
-      Xtensive.Tuples.Tuple ct3 = mt3.Apply(TupleTransformType.Tuple, t1, t1, t1);
-      TestLog.Info($"Copy:      {ct3}");
-      t1.SetValue(0,0);
-      Assert.That(t1.GetValue(0), Is.EqualTo(wt3.GetValue(4)));
-      t1.SetValue(0,1);
-
-      CombineTransform mt4 = new CombineTransform(false, t1.Descriptor, t1.Descriptor, t1.Descriptor, t1.Descriptor);
-      Xtensive.Tuples.Tuple wt4 = mt4.Apply(TupleTransformType.TransformedTuple, t1, t1, t1, t1);
-      TestLog.Info($"Wrapper:   {wt4}");
-      Xtensive.Tuples.Tuple ct4 = mt4.Apply(TupleTransformType.Tuple, t1, t1, t1, t1);
-      TestLog.Info($"Copy:      {ct4}");
-      t1.SetValue(0,0);
-      Assert.That(t1.GetValue(0), Is.EqualTo(wt4.GetValue(6)));
-      t1.SetValue(0,1);
     }
 
     [Test]
     [Explicit]
     [Category("Performance")]
-    public void PerformanceTest1()
+    public void ComparisonPerformanceTest()
     {
       AdvancedComparerStruct<Xtensive.Tuples.Tuple> comparer = AdvancedComparerStruct<Xtensive.Tuples.Tuple>.Default;
       Xtensive.Tuples.Tuple t   = Xtensive.Tuples.Tuple.Create(1);
-      CombineTransform mt = new CombineTransform(false, t.Descriptor, t.Descriptor);
+      ConcatTransform mt = new ConcatTransform(false, t.Descriptor, t.Descriptor);
       Xtensive.Tuples.Tuple wt1 = mt.Apply(TupleTransformType.TransformedTuple, t, t);
       Xtensive.Tuples.Tuple wt2 = mt.Apply(TupleTransformType.TransformedTuple, t, t);
       Xtensive.Tuples.Tuple ct1 = mt.Apply(TupleTransformType.Tuple, t, t);
@@ -96,55 +86,78 @@ public void PerformanceTest1()
       comparer.Equals(wt1, wt2);
 
       TestHelper.CollectGarbage();
-      using (new Measurement("O&O", MeasurementOptions.Log, count))
-        for (int i = 0; i<count; i++)
+      using (var mx = new Measurement("O&O", MeasurementOptions.Log, count)) {
+        for (int i = 0; i < count; i++)
           comparer.Equals(ct1, ct2);
 
+        mx.Complete();
+        Console.WriteLine(mx.ToString());
+      }
+
       TestHelper.CollectGarbage();
-      using (new Measurement("O&W", MeasurementOptions.Log, count))
-        for (int i = 0; i<count; i++)
+      using (var mx =new Measurement("O&W", MeasurementOptions.Log, count)) {
+        for (int i = 0; i < count; i++)
           comparer.Equals(ct1, wt1);
+
+        mx.Complete();
+        Console.WriteLine(mx.ToString());
+      }
 
       TestHelper.CollectGarbage();
-      using (new Measurement("W&W", MeasurementOptions.Log, count))
+      using (var mx = new Measurement("W&W", MeasurementOptions.Log, count)) {
         for (int i = 0; i<count; i++)
           comparer.Equals(wt1, wt2);
+
+        mx.Complete();
+        Console.WriteLine(mx.ToString());
+      }
     }
 
 
     [Test]
     [Explicit]
     [Category("Performance")]
-    public void PerformanceTest2()
+    public void InstanceCreationPerformanceTest()
     {
-      AdvancedComparerStruct<Xtensive.Tuples.Tuple> comparer = AdvancedComparerStruct<Xtensive.Tuples.Tuple>.Default;
-      Xtensive.Tuples.Tuple t   = Xtensive.Tuples.Tuple.Create(1);
-      CombineTransform mt = new CombineTransform(false, t.Descriptor, t.Descriptor, t.Descriptor, t.Descriptor);
-      SegmentTransform st = new SegmentTransform(false, mt.Descriptor, new Segment<int>(1,2));
-      Xtensive.Tuples.Tuple wt1 = st.Apply(TupleTransformType.TransformedTuple, mt.Apply(TupleTransformType.TransformedTuple, t, t, t, t));
-      Xtensive.Tuples.Tuple wt2 = st.Apply(TupleTransformType.TransformedTuple, mt.Apply(TupleTransformType.TransformedTuple, t, t, t, t));
-      Xtensive.Tuples.Tuple ct1 = st.Apply(TupleTransformType.Tuple, mt.Apply(TupleTransformType.Tuple, t, t, t, t));
-      Xtensive.Tuples.Tuple ct2 = st.Apply(TupleTransformType.Tuple, mt.Apply(TupleTransformType.Tuple, t, t, t, t));
-      int count = IterationCount;
-
-      comparer.Equals(ct1, ct2);
-      comparer.Equals(ct1, wt1);
-      comparer.Equals(wt1, wt2);
-
-      TestHelper.CollectGarbage();
-      using (new Measurement("O&O", MeasurementOptions.Log, count))
-        for (int i = 0; i<count; i++)
-          comparer.Equals(ct1, ct2);
-
-      TestHelper.CollectGarbage();
-      using (new Measurement("O&W", MeasurementOptions.Log, count))
-        for (int i = 0; i<count; i++)
-          comparer.Equals(ct1, wt1);
-
-      TestHelper.CollectGarbage();
-      using (new Measurement("W&W", MeasurementOptions.Log, count))
-        for (int i = 0; i<count; i++)
-          comparer.Equals(wt1, wt2);
+      Xtensive.Tuples.Tuple t1 = Xtensive.Tuples.Tuple.Create(1);
+      Xtensive.Tuples.Tuple t2 = Xtensive.Tuples.Tuple.Create(1, "2");
+      Xtensive.Tuples.Tuple t3 = Xtensive.Tuples.Tuple.Create(1, 2L, "3");
+      Xtensive.Tuples.Tuple t4 = Xtensive.Tuples.Tuple.Create(1, 2L, "3", "4");
+      Xtensive.Tuples.Tuple t5 = Xtensive.Tuples.Tuple.Create(1, 2L, "3", "4", 5);
+      Xtensive.Tuples.Tuple t6 = Xtensive.Tuples.Tuple.Create(1, 2L, "3", "4", 5, 6L);
+
+      int count = IterationCount * 10;
+
+      _ = new ConcatTransform(false, t1.Descriptor, t1.Descriptor);
+      _ = new ConcatTransform(false, t2.Descriptor, t2.Descriptor);
+      _ = new ConcatTransform(false, t3.Descriptor, t3.Descriptor);
+      _ = new ConcatTransform(false, t4.Descriptor, t4.Descriptor);
+      _ = new ConcatTransform(false, t5.Descriptor, t5.Descriptor);
+
+      for (var run = 0; run < MeasurementRuns; run++) {
+        TestHelper.CollectGarbage();
+        using (var mx = new Measurement("N1Concat", MeasurementOptions.Log, count)) {
+          for (int i = 0; i < count; i++) {
+            _ = new ConcatTransform(false, t1.Descriptor, t1.Descriptor);
+          }
+
+          mx.Complete();
+          Console.WriteLine(mx.ToString());
+        }
+      }
+
+      Console.WriteLine();
+      for (var run = 0; run < MeasurementRuns; run++) {
+        TestHelper.CollectGarbage();
+        using (var mx = new Measurement("N5Concat", MeasurementOptions.Log, count)) {
+          for (int i = 0; i < count; i++) {
+            _ = new ConcatTransform(false, t5.Descriptor, t5.Descriptor);
+          }
+
+          mx.Complete();
+          Console.WriteLine(mx.ToString());
+        }
+      }
     }
   }
 }