IgnoreRule: added Index property

Author: alex-kulakov

Orm/Xtensive.Orm/Orm/Configuration/Elements/IgnoreRuleElement.cs

@@ -1,6 +1,6 @@
-// Copyright (C) 2013 Xtensive LLC.
-// All rights reserved.
-// For conditions of distribution and use, see license.
+// Copyright (C) 2013 Xtensive LLC.
+// This code is distributed under MIT license terms.
+// See the License.txt file in the project root for more information.
 // Created by: Alexey Kulakov
 // Created:    2013.08.16
 
@@ -19,21 +19,25 @@ public class IgnoreRuleElement : ConfigurationCollectionElementBase
     private const string SchemaElementName = "schema";
     private const string TableElementName = "table";
     private const string ColumnElementName = "column";
+    private const string IndexElementName = "index";
 
     /// <inheritdoc />
-    public override object Identifier
-    {
-      get { return new Tuple<string, string, string, string>(Database ?? string.Empty, Schema ?? string.Empty, Table ?? string.Empty, Column ?? string.Empty); }
-    }
+    public override object Identifier => 
+      new Tuple<string, string, string, string, string>(
+        Database ?? string.Empty,
+        Schema ?? string.Empty,
+        Table ?? string.Empty,
+        Column ?? string.Empty,
+        Index ?? string.Empty);
 
     /// <summary>
     /// <see cref="IgnoreRule.Database" copy="true"/>
     /// </summary>
     [ConfigurationProperty(DatabaseElementName)]
     public string Database
     {
-      get { return (string)this[DatabaseElementName]; }
-      set { this[DatabaseElementName] = value; }
+      get => (string) this[DatabaseElementName];
+      set => this[DatabaseElementName] = value;
     }
 
     /// <summary>
@@ -42,8 +46,8 @@ public string Database
     [ConfigurationProperty(SchemaElementName)]
     public string Schema
     {
-      get { return (string) this[SchemaElementName]; }
-      set { this[SchemaElementName] = value; }
+      get => (string) this[SchemaElementName];
+      set => this[SchemaElementName] = value;
     }
 
     /// <summary>
@@ -52,8 +56,8 @@ public string Schema
     [ConfigurationProperty(TableElementName)]
     public string Table
     {
-      get { return (string) this[TableElementName]; }
-      set { this[TableElementName] = value; }
+      get => (string) this[TableElementName];
+      set => this[TableElementName] = value;
     }
 
     /// <summary>
@@ -62,17 +66,24 @@ public string Table
     [ConfigurationProperty(ColumnElementName)]
     public string Column
     {
-      get { return (string)this[ColumnElementName]; }
-      set { this[ColumnElementName] = value; }
+      get => (string) this[ColumnElementName];
+      set => this[ColumnElementName] = value;
     }
 
     /// <summary>
-    /// Converts this instance to corresponding <see cref="IgnoreRule"/>.
+    /// <see cref="IgnoreRule.Index"/>
     /// </summary>
-    /// <returns>Result of conversion.</returns>
-    public IgnoreRule ToNative()
+    [ConfigurationProperty(IndexElementName)]
+    public string Index
     {
-      return new IgnoreRule(Database, Schema, Table, Column);
+      get => (string) this[IndexElementName];
+      set => this[IndexElementName] = value;
     }
+
+    /// <summary>
+    /// Converts this instance to corresponding <see cref="IgnoreRule"/>.
+    /// </summary>
+    /// <returns>Result of conversion.</returns>
+    public IgnoreRule ToNative() => new IgnoreRule(Database, Schema, Table, Column, Index);
   }
 }

Orm/Xtensive.Orm/Orm/Configuration/IgnoreRule.cs

@@ -1,105 +1,119 @@
-// Copyright (C) 2013 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: Alexey Kulakov
 // Created:    2013.08.16
 
+using System;
 using System.Text;
 using Xtensive.Core;
 
 namespace Xtensive.Orm.Configuration
 {
   /// <summary>
-  /// Ignore rules for presistent types
+  /// Ignore rule for items in database (tables, columns, indexes).
   /// </summary>
   public sealed class IgnoreRule : LockableBase
   {
     private string database;
     private string schema;
     private string table;
     private string column;
-
+    private string index;
 
     /// <summary>
-    /// Gets database that is assigned to ignored type when this rule is applied
+    /// Gets database that the rule should be applied to.
     /// If this property is set to null or empty value <see cref="DomainConfiguration.DefaultDatabase"/>
     /// is used instead.
     /// </summary>
     public string Database
     {
-      get { return database; }
-      set
-      {
+      get => database;
+      set {
         EnsureNotLocked();
         database = value;
       }
     }
 
     /// <summary>
-    /// Get schema that is assigned to ignored type when this rule is applied
+    /// Get schema that the rule should be applied to.
     /// If this property is set to null or empty value <see cref="DomainConfiguration.DefaultSchema"/>
     /// is used instead.
     /// </summary>
     public string Schema
     {
-      get { return schema; }
-      set
-      {
+      get => schema;
+      set {
         EnsureNotLocked();
         schema = value;
       }
     }
 
 
     /// <summary>
-    /// Gets table condition.
-    /// When type is declared in the specified table, this rule is applied.
+    /// Gets table condition (exact name, prefix or suffix by using asterisk).
     /// If this property is set to null value, any table matches this rule.
     /// </summary>
     public string Table
     {
-      get { return table; }
-      set
-      {
+      get => table;
+      set {
         EnsureNotLocked();
         table = value;
       }
     }
 
     /// <summary>
-    /// Gets column condition
-    /// When type is declared in the specified column, this rule is applied.
+    /// Gets column condition (exact name, prefix or suffix by using asterisk).
     /// If this property is set to null value, any culumn matches this rule.
     /// </summary>
+    /// <remarks>Either <see cref="Column"/> or <see cref="Index"/> can be declared.</remarks>
     public string Column
     {
-      get { return column; }
-      set
-      {
+      get => column;
+      set {
+        EnsureNotLocked();
+        SetColumnWithCheck(value);
+      }
+    }
+
+    /// <summary>
+    /// Gets index condition (exact name, prefix or suffix by using asterisk).
+    /// If this property is set to null value, any index matches this rule.
+    /// </summary>
+    /// <remarks>Either <see cref="Index"/> or <see cref="Column"/> can be declared.</remarks>
+    public string Index
+    {
+      get => index;
+      set {
         EnsureNotLocked();
-        column = value;
+        SetIndexWithCheck(value);
       }
     }
 
     /// <inheritdoc />
     public override string ToString()
     {
       var separator = ", ";
-      StringBuilder sb = new StringBuilder();
-      
+
       var databasePart = !string.IsNullOrEmpty(database) ? $"Database = {database}" : "<default database>";
       var schemaPart = !string.IsNullOrEmpty(schema) ? $"Schema = {schema}" : "<default schema>";
       var tablePart = !string.IsNullOrEmpty(table) ? $"Table = {table}" : "<any table>";
-      var columnPart = !string.IsNullOrEmpty(column) ? $"Column = {column}" : "<any column>";
-      sb.Append(databasePart)
+
+      var columnOrIndexPart = !string.IsNullOrEmpty(column)
+        ? $"Column = {column}"
+        : (!string.IsNullOrEmpty(index))
+          ? $"Index = {index}"
+          : "<any column> OR <any index>";
+
+      return new StringBuilder(databasePart)
         .Append(separator)
         .Append(schemaPart)
         .Append(separator)
         .Append(tablePart)
         .Append(separator)
-        .Append(columnPart);
-
-      return sb.ToString();
+        .Append(columnOrIndexPart)
+        .ToString();
     }
 
     /// <summary>
@@ -108,7 +122,23 @@ public override string ToString()
     /// <returns>Cloned instance</returns>
     public IgnoreRule Clone()
     {
-      return new IgnoreRule(database, schema, table, column);
+      return new IgnoreRule(database, schema, table, column, index);
+    }
+
+    private void SetColumnWithCheck(in string columnToSet)
+    {
+      if (!string.IsNullOrEmpty(columnToSet) && !string.IsNullOrEmpty(index)) {
+        throw new InvalidOperationException(string.Format(Strings.ExIgnoreRuleIsAlreadyConfiguredForX, nameof(Index)));
+      }
+      column = columnToSet;
+    }
+
+    private void SetIndexWithCheck(in string indexToSet)
+    {
+      if (!string.IsNullOrEmpty(indexToSet) && !string.IsNullOrEmpty(column)) {
+        throw new InvalidOperationException(string.Format(Strings.ExIgnoreRuleIsAlreadyConfiguredForX, nameof(Column)));
+      }
+      index = indexToSet;
     }
 
     //Constructors
@@ -127,12 +157,14 @@ public IgnoreRule()
     /// <param name="schema">Value for <see cref="Schema"/></param>
     /// <param name="table">Value for <see cref="Table"/></param>
     /// <param name="column">Value for <see cref="Column"/></param>
-    public IgnoreRule (string database, string schema, string table, string column)
+    /// <param name="index">Value for <see cref="Index"/></param>
+    internal IgnoreRule(in string database, in string schema, in string table, in string column, in string index)
     {
       Database = database;
       Schema = schema;
       Table = table;
       Column = column;
+      Index = index;
     }
   }
 }

Orm/Xtensive.Orm/Strings.Designer.cs

@@ -2582,4 +2582,7 @@ Error: {1}</value>
   <data name="ExGivenTypeHasNoOrMoreThanOneCtorWithGivenParameters" xml:space="preserve">
     <value>The given type has no constructor with given parameters or more than one suitable constructor.</value>
   </data>
+  <data name="ExIgnoreRuleIsAlreadyConfiguredForX" xml:space="preserve">
+    <value>Rule is already configured for {0}.</value>
+  </data>
 </root>