Merge pull request #282 from DataObjects-NET/master-ignore-indexes

Adds ability to ignore indexes as well as columns

Author: alex-kulakov

ChangeLog/7.1.0-Beta-2-dev.txt

@@ -12,6 +12,8 @@
 [main] SqlCustomFunctionCall and SqlFunctionCall share one base type
 [main] SqlFunctionCall.Arguments property is IReadOnlyList now and parameters can't be changed after instance creation
 [main] Xtensive.Sql.Dml.Extensions.IsNullReference() extension method is marked obsolete, use 'is null' operator instead
+[main] IgnoreRule now has only one public constructor - parameterless
+[main] IgnoreRule supports indexes
 [main] BitFaster.Caching package reference is updated to 1.0.7
 [main] No error caused by ambiguity due to new IQueryable extension methods of .Net 6
 [reprocessing] DomainBuildErrorEventArgs (not sealed) became read-only structure

Orm/Xtensive.Orm.Tests/App.config

@@ -125,15 +125,22 @@
         <ignoreRules>
           <rule database="Other-DO40-Tests" schema="some-schema1" table="table1"/>
           <rule database="some-database" schema="some-schema2" column="column2"/>
+          <rule database="some-database" schema="some-schema2" index="index2"/>
           <rule database="some-database" schema="some-schema3" table="table2" column="col3"/>
+          <rule database="some-database" schema="some-schema3" table="table2" index="index3"/>
           <rule database="another-some-database" table="some-table" />
           <rule database="database1" column ="some-column"/>
+          <rule database="database1" index ="some-index"/>
           <rule schema="schema1" table="table1"/>
           <rule schema="schema1" column="column2"/>
+          <rule schema="schema1" index="index2" />
           <rule schema="schema1" table="table2" column="column3"/>
+          <rule schema="schema1" table="table2" index="index3"/>
           <rule table="table4" column="column3"/>
+          <rule table="table4" index ="index2" />
           <rule table="single-table"/>
           <rule column="single-column"/>
+          <rule index ="single-index" />
         </ignoreRules>
         <databases>
           <database name="main" realName="DO40-Tests" />

Orm/Xtensive.Orm.Tests/Configuration/AppConfigTest.cs

@@ -203,8 +203,8 @@ public void IgnoreRuleConfigTest()
 
       var good = configuration.Clone();
       good.IgnoreRules.Clear();
-      good.IgnoreRules.IgnoreTable("ignored-table").WhenDatabase("Other-DO40-Test").WhenSchema("dbo");
-      good.IgnoreRules.IgnoreColumn("ignored-column");
+      _ = good.IgnoreRules.IgnoreTable("ignored-table").WhenDatabase("Other-DO40-Test").WhenSchema("dbo");
+      _ = good.IgnoreRules.IgnoreColumn("ignored-column");
       good.Lock();
     }
 
@@ -382,13 +382,136 @@ private void ValidateIgnoringConfiguration(DomainConfiguration configuration)
     {
       Assert.That(configuration.DefaultDatabase, Is.EqualTo("main"));
       Assert.That(configuration.DefaultSchema, Is.EqualTo("dbo"));
-      Assert.That(configuration.IgnoreRules.Count, Is.EqualTo(11));
-      var rule = configuration.IgnoreRules[0];
+
+      var rules = configuration.IgnoreRules;
+      Assert.That(rules.Count, Is.EqualTo(18));
+
+      var rule = rules[0];
       Assert.That(rule.Database, Is.EqualTo("Other-DO40-Tests"));
-      var rule2 = configuration.IgnoreRules[2];
-      Assert.That(rule2.Schema, Is.EqualTo("some-schema3"));
-      Assert.That(rule2.Table, Is.EqualTo("table2"));
-      Assert.That(rule2.Column, Is.EqualTo("col3"));
+      Assert.That(rule.Schema, Is.EqualTo("some-schema1"));
+      Assert.That(rule.Table, Is.EqualTo("table1"));
+      Assert.That(rule.Column, Is.Null.Or.Empty);
+      Assert.That(rule.Index, Is.Null.Or.Empty);
+
+      rule = rules[1];
+      Assert.That(rule.Database, Is.EqualTo("some-database"));
+      Assert.That(rule.Schema, Is.EqualTo("some-schema2"));
+      Assert.That(rule.Table, Is.Null.Or.Empty);
+      Assert.That(rule.Column, Is.EqualTo("column2"));
+      Assert.That(rule.Index, Is.Null.Or.Empty);
+
+      rule = rules[2];
+      Assert.That(rule.Database, Is.EqualTo("some-database"));
+      Assert.That(rule.Schema, Is.EqualTo("some-schema2"));
+      Assert.That(rule.Table, Is.Null.Or.Empty);
+      Assert.That(rule.Column, Is.Null.Or.Empty);
+      Assert.That(rule.Index, Is.EqualTo("index2"));
+
+      rule = rules[3];
+      Assert.That(rule.Database, Is.EqualTo("some-database"));
+      Assert.That(rule.Schema, Is.EqualTo("some-schema3"));
+      Assert.That(rule.Table, Is.EqualTo("table2"));
+      Assert.That(rule.Column, Is.EqualTo("col3"));
+      Assert.That(rule.Index, Is.Null.Or.Empty);
+
+      rule = rules[4];
+      Assert.That(rule.Database, Is.EqualTo("some-database"));
+      Assert.That(rule.Schema, Is.EqualTo("some-schema3"));
+      Assert.That(rule.Table, Is.EqualTo("table2"));
+      Assert.That(rule.Column, Is.Null.Or.Empty);
+      Assert.That(rule.Index, Is.EqualTo("index3"));
+
+      rule = rules[5];
+      Assert.That(rule.Database, Is.EqualTo("another-some-database"));
+      Assert.That(rule.Schema, Is.Null.Or.Empty);
+      Assert.That(rule.Table, Is.EqualTo("some-table"));
+      Assert.That(rule.Column, Is.Null.Or.Empty);
+      Assert.That(rule.Index, Is.Null.Or.Empty);
+
+      rule = rules[6];
+      Assert.That(rule.Database, Is.EqualTo("database1"));
+      Assert.That(rule.Schema, Is.Null.Or.Empty);
+      Assert.That(rule.Table, Is.Null.Or.Empty);
+      Assert.That(rule.Column, Is.EqualTo("some-column"));
+      Assert.That(rule.Index, Is.Null.Or.Empty);
+
+      rule = rules[7];
+      Assert.That(rule.Database, Is.EqualTo("database1"));
+      Assert.That(rule.Schema, Is.Null.Or.Empty);
+      Assert.That(rule.Table, Is.Null.Or.Empty);
+      Assert.That(rule.Column, Is.Null.Or.Empty);
+      Assert.That(rule.Index, Is.EqualTo("some-index"));
+
+      rule = rules[8];
+      Assert.That(rule.Database, Is.Null.Or.Empty);
+      Assert.That(rule.Schema, Is.EqualTo("schema1"));
+      Assert.That(rule.Table, Is.EqualTo("table1"));
+      Assert.That(rule.Column, Is.Null.Or.Empty);
+      Assert.That(rule.Index, Is.Null.Or.Empty);
+
+      rule = rules[9];
+      Assert.That(rule.Database, Is.Null.Or.Empty);
+      Assert.That(rule.Schema, Is.EqualTo("schema1"));
+      Assert.That(rule.Table, Is.Null.Or.Empty);
+      Assert.That(rule.Column, Is.EqualTo("column2"));
+      Assert.That(rule.Index, Is.Null.Or.Empty);
+
+      rule = rules[10];
+      Assert.That(rule.Database, Is.Null.Or.Empty);
+      Assert.That(rule.Schema, Is.EqualTo("schema1"));
+      Assert.That(rule.Table, Is.Null.Or.Empty);
+      Assert.That(rule.Column, Is.Null.Or.Empty);
+      Assert.That(rule.Index, Is.EqualTo("index2"));
+
+      rule = rules[11];
+      Assert.That(rule.Database, Is.Null.Or.Empty);
+      Assert.That(rule.Schema, Is.EqualTo("schema1"));
+      Assert.That(rule.Table, Is.EqualTo("table2"));
+      Assert.That(rule.Column, Is.EqualTo("column3"));
+      Assert.That(rule.Index, Is.Null.Or.Empty);
+
+      rule = rules[12];
+      Assert.That(rule.Database, Is.Null.Or.Empty);
+      Assert.That(rule.Schema, Is.EqualTo("schema1"));
+      Assert.That(rule.Table, Is.EqualTo("table2"));
+      Assert.That(rule.Column, Is.Null.Or.Empty);
+      Assert.That(rule.Index, Is.EqualTo("index3"));
+
+      rule = rules[13];
+      Assert.That(rule.Database, Is.Null.Or.Empty);
+      Assert.That(rule.Schema, Is.Null.Or.Empty);
+      Assert.That(rule.Table, Is.EqualTo("table4"));
+      Assert.That(rule.Column, Is.EqualTo("column3"));
+      Assert.That(rule.Index, Is.Null.Or.Empty);
+
+      rule = rules[14];
+      Assert.That(rule.Database, Is.Null.Or.Empty);
+      Assert.That(rule.Schema, Is.Null.Or.Empty);
+      Assert.That(rule.Table, Is.EqualTo("table4"));
+      Assert.That(rule.Column, Is.Null.Or.Empty);
+      Assert.That(rule.Index, Is.EqualTo("index2"));
+
+      rule = rules[15];
+      Assert.That(rule.Database, Is.Null.Or.Empty);
+      Assert.That(rule.Schema, Is.Null.Or.Empty);
+      Assert.That(rule.Table, Is.EqualTo("single-table"));
+      Assert.That(rule.Column, Is.Null.Or.Empty);
+      Assert.That(rule.Index, Is.Null.Or.Empty);
+
+      rule = rules[16];
+      Assert.That(rule.Database, Is.Null.Or.Empty);
+      Assert.That(rule.Schema, Is.Null.Or.Empty);
+      Assert.That(rule.Table, Is.Null.Or.Empty);
+      Assert.That(rule.Column, Is.EqualTo("single-column"));
+      Assert.That(rule.Index, Is.Null.Or.Empty);
+
+      rule = rules[17];
+      Assert.That(rule.Database, Is.Null.Or.Empty);
+      Assert.That(rule.Schema, Is.Null.Or.Empty);
+      Assert.That(rule.Table, Is.Null.Or.Empty);
+      Assert.That(rule.Column, Is.Null.Or.Empty);
+      Assert.That(rule.Index, Is.EqualTo("single-index"));
+
       var databases = configuration.Databases;
       Assert.That(databases.Count, Is.EqualTo(2));
       Assert.That(databases[0].Name, Is.EqualTo("main"));

Orm/Xtensive.Orm.Tests/Configuration/SchemaTest.cs

@@ -1,11 +1,10 @@
-// Copyright (C) 2003-2010 Xtensive LLC.
-// All rights reserved.
-// For conditions of distribution and use, see license.
+// Copyright (C) 2013-2022 Xtensive LLC.
+// This code is distributed under MIT license terms.
+// See the License.txt file in the project root for more information.
 // Created by: Alena Mikshina
 // Created:    2013.10.04
 
 using System;
-using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
 using System.Xml;
@@ -18,39 +17,41 @@ namespace Xtensive.Orm.Tests.Configuration
   [TestFixture]
   public class SchemaTest
   {
-    private const string originalConfigFileName = "Xtensive.Orm.Tests.dll.config";
-    private const string xsdFileName = "Xtensive.Orm.xsd";
-    private const string xsdInLowerCaseFileName = "Test.xsd";
-    private const string configFileName = "Test.config";
-    private const string originalRootElementName = "AppConfigTest";
-    private const string rootElementName = "Xtensive.Orm";
-    private const string configXmlNamespace = "http://dataobjects.net/schemas/appconfig/";
+    private const string OriginalConfigFileName = "Xtensive.Orm.Tests.dll.config";
+    private const string XsdFileName = "Xtensive.Orm.xsd";
+    private const string XsdInLowerCaseFileName = "Test.xsd";
+    private const string ConfigFileName = "Test.config";
+    private const string OriginalRootElementName = "AppConfigTest";
+    private const string RootElementName = "Xtensive.Orm";
+    private const string ConfigXmlNamespace = "http://dataobjects.net/schemas/appconfig/";
     private bool hasErrors;
 
     [Test]
     public void TestSchema()
     {
       hasErrors = false;
 
-      XElement segmentConfig = XElement.Load(originalConfigFileName).Element(originalRootElementName);
-      Debug.Assert(segmentConfig!=null, "segmentConfig != null");
-      segmentConfig.Name = rootElementName;
+      var segmentConfig = XElement.Load(OriginalConfigFileName).Element(OriginalRootElementName);
+      Debug.Assert(segmentConfig != null, "segmentConfig != null");
+      segmentConfig.Name = RootElementName;
 
-      foreach (XElement element in segmentConfig.DescendantsAndSelf())
-        element.Name = (XNamespace) configXmlNamespace + element.Name.LocalName;
+      foreach (var element in segmentConfig.DescendantsAndSelf()) {
+        element.Name = (XNamespace) ConfigXmlNamespace + element.Name.LocalName;
+      }
 
-      using (StreamWriter segmentConfigWriter = File.CreateText(configFileName))
+      using (var segmentConfigWriter = File.CreateText(ConfigFileName)) {
         segmentConfigWriter.Write(segmentConfig.ToString().ToLower());
+      }
 
       ChangeXsdElementsToLowerCase();
 
       try {
-        XmlReaderSettings schemaSettings = new XmlReaderSettings();
-        schemaSettings.Schemas.Add(configXmlNamespace, xsdInLowerCaseFileName);
+        var schemaSettings = new XmlReaderSettings();
+        _ = schemaSettings.Schemas.Add(ConfigXmlNamespace, XsdInLowerCaseFileName);
         schemaSettings.ValidationType = ValidationType.Schema;
         schemaSettings.ValidationEventHandler += new ValidationEventHandler(ValidationHandler);
 
-        XmlReader configReader = XmlReader.Create(configFileName, schemaSettings);
+        var configReader = XmlReader.Create(ConfigFileName, schemaSettings);
         while (configReader.Read()) {
         }
         configReader.Close();
@@ -61,12 +62,6 @@ public void TestSchema()
         Console.WriteLine("LineNumber = {0}", exception.LineNumber);
         Console.WriteLine("LinePosition = {0}", exception.LinePosition);
       }
-      catch (XmlSchemaValidationException exception) {
-        hasErrors = true;
-        Console.WriteLine("{0}: {1}", exception.GetType(), exception.Message);
-        Console.WriteLine("LineNumber = {0}", exception.LineNumber);
-        Console.WriteLine("LinePosition = {0}", exception.LinePosition);
-      }
       catch (XmlSchemaException exception) {
         hasErrors = true;
         Console.WriteLine("{0}: {1}", exception.GetType(), exception.Message);
@@ -86,33 +81,39 @@ public void TestSchema()
         Console.WriteLine("{0}: {1}", exception.GetType(), exception.Message);
       }
       finally {
-        File.Delete(configFileName);
-        File.Delete(xsdInLowerCaseFileName);
+        File.Delete(ConfigFileName);
+        File.Delete(XsdInLowerCaseFileName);
       }
 
       Assert.IsFalse(hasErrors);
     }
 
-    public void ValidationHandler(object sender, ValidationEventArgs exception)
+    public void ValidationHandler(object sender, ValidationEventArgs validationEventArgs)
     {
       hasErrors = true;
-      Console.WriteLine("({0}) {1}: {2}", exception.Severity, exception.GetType(), exception.Message);
+      var exception = validationEventArgs.Exception;
+      Console.WriteLine($"({validationEventArgs.Severity}) {exception.GetType()}: {validationEventArgs.Message}");
+      Console.WriteLine($"LineNumber = {exception.LineNumber}");
+      Console.WriteLine($"LinePosition = {exception.LinePosition}");
     }
 
     private static void ChangeXsdElementsToLowerCase()
     {
-      var elementsUsedInXsd = new List<string> {"element", "complexType", "attribute", "simpleType", "restriction", "enumeration", "pattern"};
+      var elementsUsedInXsd = new string[] { "element", "complexType", "attribute", "simpleType", "restriction", "enumeration", "pattern" };
 
-      XNamespace namespaceXsd = XNamespace.Get("http://www.w3.org/2001/XMLSchema");
-      XElement xsdWithElementsToLowerCase = XElement.Load(xsdFileName);
+      var namespaceXsd = XNamespace.Get("http://www.w3.org/2001/XMLSchema");
+      var xsdWithElementsToLowerCase = XElement.Load(XsdFileName);
 
-      foreach (var element in elementsUsedInXsd)
-        foreach (var attributes in xsdWithElementsToLowerCase.Descendants(namespaceXsd + element))
-          foreach (var attribute in attributes.Attributes())
+      foreach (var element in elementsUsedInXsd) {
+        foreach (var attributes in xsdWithElementsToLowerCase.Descendants(namespaceXsd + element)) {
+          foreach (var attribute in attributes.Attributes()) {
             attribute.Value = attribute.Value.ToLower();
+          }
+        }
+      }
 
-      using (StreamWriter xElementXsdWriter = File.CreateText(xsdInLowerCaseFileName))
-        xElementXsdWriter.Write(xsdWithElementsToLowerCase);
+      using var xElementXsdWriter = File.CreateText(XsdInLowerCaseFileName);
+      xElementXsdWriter.Write(xsdWithElementsToLowerCase);
     }
   }
 }