Merge pull request #637 from gumbarros/dev

Add support for specifying non-clustered index sort direction

Author: ckadluba

README.md

@@ -110,6 +110,7 @@ columnOpts.Store.Add(StandardColumn.LogEvent);
 columnOpts.LogEvent.DataLength = 2048;
 columnOpts.PrimaryKey = columnOpts.TimeStamp;
 columnOpts.TimeStamp.NonClusteredIndex = true;
+columnOpts.TimeStamp.NonClusteredIndexDirection = SqlIndexDirection.Desc;
 
 var log = new LoggerConfiguration()
     .WriteTo.MSSqlServer(
@@ -349,6 +350,7 @@ Each Standard Column in the `ColumnOptions.Store` list and any custom columns yo
 * `AllowNull`
 * `DataLength`
 * `NonClusteredIndex`
+* `NonClusteredIndexDirection`
 
 ### ColumnName
 
@@ -412,9 +414,20 @@ Supported SQL column data types that use this property:
 
 Any individual column can be defined as a non-clustered index, including the table primary key. Use this with caution, indexing carries a relatively high write-throughput penalty. One way to mitigate this is to keep non-clustered indexes offline and use batch reindexing on a scheduled basis.
 
+### NonClusteredIndexDirection
+
+Specifies the sort direction (`ASC` or `DESC`) for a non-clustered index on the SQL column.
+The default value is `ASC`.
+
+It is especially useful for the timestamp column,
+where choosing the correct sort direction can optimize query performance for workloads that typically scan
+recent data first.
+
+This only has effect if `NonClusteredIndex` is `true`.
+
 ## Standard Columns
 
-By default (and consistent with the SQL DDL to create a table shown earlier) these columns are included in a new `ColumnOptions.Store` list:
+By default (and consistent with the SQL DDL to create a table shown earlier), these columns are included in a new `ColumnOptions.Store` list:
 
  - `StandardColumn.Id`
  - `StandardColumn.Message`

sample/WorkerServiceDemo/appsettings.json

@@ -25,7 +25,10 @@
             "removeStandardColumns": [ "MessageTemplate", "Properties" ],
             "timeStamp": {
               "columnName": "Timestamp",
-              "convertToUtc": false
+              "allowNulls": false,
+              "convertToUtc": false,
+              "nonClusteredIndex": true,
+              "nonClusteredIndexDirection": "Desc"
             },
             "customColumns": [
               {
@@ -43,6 +46,12 @@
                 "propertyName": "NonstructuredProperty.WithNameContainingDots.Name",
                 "resolveHierarchicalPropertyName": false,
                 "dataType": "12"
+              },
+              {
+                "columnName": "AdditionalColumn4",
+                "dataType": "0",
+                "nonClusteredIndex": true,
+                "nonClusteredIndexDirection": "Desc"
               }
             ]
           },

src/Serilog.Sinks.MSSqlServer/Configuration/Implementations/Microsoft.Extensions.Configuration/MicrosoftExtensionsColumnOptionsProvider.cs

@@ -34,6 +34,8 @@ private static void SetCommonColumnOptions(IConfigurationSection section, SqlCol
             SetProperty.IfNotNull<bool>(section["allowNull"], (val) => target.AllowNull = val);
             SetProperty.IfNotNull<int>(section["dataLength"], (val) => target.DataLength = val);
             SetProperty.IfNotNull<bool>(section["nonClusteredIndex"], (val) => target.NonClusteredIndex = val);
+            SetProperty.IfEnumNotNull<SqlIndexDirection>(section["nonClusteredIndexDirection"],
+                (val) => target.NonClusteredIndexDirection = val);
         }
 
         private static void AddRemoveStandardColumns(IConfigurationSection config, ColumnOptions columnOptions)

src/Serilog.Sinks.MSSqlServer/Configuration/Implementations/SetProperty.cs

@@ -29,7 +29,25 @@ public static void IfNotNull<T>(string value, PropertySetter<T> setter)
                 var setting = (T)Convert.ChangeType(value, typeof(T), CultureInfo.InvariantCulture);
                 setter(setting);
             }
-            // don't change the property if the conversion fails 
+            // don't change the property if the conversion fails
+            catch (InvalidCastException) { }
+            catch (OverflowException) { }
+        }
+
+        /// <summary>
+        /// This will only set a value (execute the PropertySetter delegate) if the value is non-null.
+        /// It also converts the provided value to the requested enum type. This allows configuration to only
+        /// apply property changes when external configuration has actually provided a value.
+        /// </summary>
+        public static void IfEnumNotNull<T>(string value, PropertySetter<T> setter) where T : System.Enum
+        {
+            if (value == null || setter == null) return;
+            try
+            {
+                var setting = (T)Enum.Parse(typeof(T), value, ignoreCase: true);
+                setter(setting);
+            }
+            // don't change the property if the conversion fails
             catch (InvalidCastException) { }
             catch (OverflowException) { }
         }

src/Serilog.Sinks.MSSqlServer/Configuration/Implementations/System.Configuration/ColumnConfig.cs

@@ -83,6 +83,13 @@ public string NonClusteredIndex
             set { this[nameof(NonClusteredIndex)] = value; }
         }
 
+        [ConfigurationProperty("NonClusteredIndexDirection")]
+        public string NonClusteredIndexDirection
+        {
+            get { return (string)this[nameof(NonClusteredIndexDirection)]; }
+            set { this[nameof(NonClusteredIndexDirection)] = value; }
+        }
+
         internal SqlColumn AsSqlColumn()
         {
             var sqlColumn = new SqlColumn();
@@ -106,6 +113,9 @@ internal SqlColumn AsSqlColumn()
 
             SetProperty.IfProvided<bool>(this, nameof(NonClusteredIndex), (val) => sqlColumn.NonClusteredIndex = val);
 
+            SetProperty.IfEnumProvided<SqlIndexDirection>(this, nameof(NonClusteredIndexDirection),
+                (val) => sqlColumn.NonClusteredIndexDirection = val);
+
             return sqlColumn;
         }
     }

src/Serilog.Sinks.MSSqlServer/Configuration/Implementations/System.Configuration/SetPropertyValueOrigin.cs

@@ -22,6 +22,22 @@ public static void IfProvided<T>(ConfigurationElement element, string propertyNa
             IfNotNull((string)property.Value, setter);
         }
 
+        /// <summary>
+        /// Test the underlying enum property collection's value-origin flag for a non-default string value. Empty strings allowed.
+        /// </summary>
+        public static void IfEnumProvided<T>(ConfigurationElement element, string propertyName, PropertySetter<T> setter)
+            where T : System.Enum
+        {
+            if (element == null)
+            {
+                return;
+            }
+
+            var property = element.ElementInformation.Properties[propertyName];
+            if (property.ValueOrigin == PropertyValueOrigin.Default) return;
+            IfEnumNotNull((string)property.Value, setter);
+        }
+
         /// <summary>
         /// Test the underlying property collection's value-origin flag for a non-default, non-null, non-empty string value.
         /// </summary>

src/Serilog.Sinks.MSSqlServer/Configuration/Implementations/System.Configuration/SystemConfigurationColumnOptionsProvider.cs

@@ -26,6 +26,7 @@ private static void SetCommonColumnOptions(ColumnConfig source, SqlColumn target
             SetProperty.IfProvided<bool>(source, nameof(target.AllowNull), value => target.AllowNull = value);
             SetProperty.IfProvided<int>(source, nameof(target.DataLength), value => target.DataLength = value);
             SetProperty.IfProvided<bool>(source, nameof(target.NonClusteredIndex), value => target.NonClusteredIndex = value);
+            SetProperty.IfEnumProvided<SqlIndexDirection>(source, nameof(target.NonClusteredIndexDirection), value => target.NonClusteredIndexDirection = value);
         }
 
         private static void ReadPropertiesColumnOptions(MSSqlServerConfigurationSection config, ColumnOptions columnOptions)

src/Serilog.Sinks.MSSqlServer/Sinks/MSSqlServer/Platform/SqlCreateTableWriter.cs

@@ -54,7 +54,7 @@ public string GetSql()
 
                     // collect non-PK indexes for separate output after the table DDL
                     if (common != null && common.NonClusteredIndex && common != _columnOptions.PrimaryKey)
-                        ix.AppendLine(Invariant($"CREATE NONCLUSTERED INDEX [IX{indexCount++}_{_tableName}] ON [{_schemaName}].[{_tableName}] ([{common.ColumnName}]);"));
+                        ix.AppendLine(Invariant($"CREATE NONCLUSTERED INDEX [IX{indexCount++}_{_tableName}] ON [{_schemaName}].[{_tableName}] ([{common.ColumnName}] {common.NonClusteredIndexDirection});"));
                 }
             }
 

src/Serilog.Sinks.MSSqlServer/Sinks/MSSqlServer/SqlColumn.cs

@@ -100,6 +100,12 @@ public SqlDbType DataType
         /// </summary>
         public bool NonClusteredIndex { get; set; }
 
+        /// <summary>
+        /// Specifies the sort direction for a non-clustered index on the SQL column.
+        /// The default value is <see cref="SqlIndexDirection.Asc"/>. This property is only used when auto-creating a log table.
+        /// </summary>
+        public SqlIndexDirection NonClusteredIndexDirection { get; set; }
+
         /// <summary>
         /// The name of the Serilog property to use as the value when filling the DataTable.
         /// If not specified, the ColumnName and PropertyName are the same.

src/Serilog.Sinks.MSSqlServer/Sinks/MSSqlServer/SqlIndexDirection.cs

@@ -0,0 +1,18 @@
+namespace Serilog.Sinks.MSSqlServer
+{
+    /// <summary>
+    /// Defines the sort order for an SQL index.
+    /// </summary>
+    public enum SqlIndexDirection
+    {
+        /// <summary>
+        /// Represents the ascending direction for SQL indexing.
+        /// </summary>
+        Asc,
+
+        /// <summary>
+        /// Represents the descending direction for SQL indexing.
+        /// </summary>
+        Desc
+    }
+}