Merge pull request #245 from servicetitan/upstream/Optimize_FunctionCall

Optimize SqlFunctionCall/SqlCustomFunctionCall

- Make abstract class SqlFunctionCallBase with functionality common for both SqlFunctionCall & SqlCustomFunctionCall
- Change type of SqlFunctionCall.Arguments to IReadOnlyList to avoid unnecessary allocations. Argument list is now immutable.
- Replace Collection<SqlExpression> to List<SqlExpression>. List is more lightweight with same functionality
- Make ArgumentValidator.EnsureArgumentIs<T>() to return T to avoid double type casting after call
- Make EnsureArgumentIs's parameter parameterName automatic by using [CallerArgumentExpression] attribute
- Remove invocation of EnsureArgumentNotNull before EnsureArgumentIs because the later checks for null as well.

Author: alex-kulakov

Orm/Xtensive.Orm.Firebird/Sql.Drivers.Firebird/v2_5/Compiler.cs

@@ -9,6 +9,7 @@
 using Xtensive.Sql.Compiler;
 using Xtensive.Sql.Ddl;
 using Xtensive.Sql.Dml;
+using Xtensive.Core;
 
 namespace Xtensive.Sql.Drivers.Firebird.v2_5
 {
@@ -171,9 +172,7 @@ public override void Visit(SqlFunctionCall node)
     {
       switch (node.FunctionType) {
         case SqlFunctionType.Concat:
-          var exprs = new SqlExpression[node.Arguments.Count];
-          node.Arguments.CopyTo(exprs, 0);
-          Visit(SqlDml.Concat(exprs));
+          Visit(SqlDml.Concat(node.Arguments.ToArray(node.Arguments.Count)));
           return;
         case SqlFunctionType.DateTimeTruncate:
           Visit(SqlDml.Cast(node.Arguments[0], new SqlValueType("Date")));

Orm/Xtensive.Orm.MySql/Sql.Drivers.MySql/v5_0/Compiler.cs

@@ -9,6 +9,7 @@
 using Xtensive.Sql.Ddl;
 using Xtensive.Sql.Dml;
 using Xtensive.Sql.Model;
+using Xtensive.Core;
 
 namespace Xtensive.Sql.Drivers.MySql.v5_0
 {
@@ -142,9 +143,7 @@ public override void Visit(SqlFunctionCall node)
           SqlDml.FunctionCall("TRUNCATE", argument, SqlDml.Literal(0)).AcceptVisitor(this);
           return;
         case SqlFunctionType.Concat:
-          var exprs = new SqlExpression[node.Arguments.Count];
-          node.Arguments.CopyTo(exprs, 0);
-          Visit(SqlDml.Concat(exprs));
+          Visit(SqlDml.Concat(node.Arguments.ToArray(node.Arguments.Count)));
           return;
         case SqlFunctionType.CharLength:
           SqlDml.FunctionCall(translator.TranslateToString(SqlFunctionType.CharLength), node.Arguments[0]).AcceptVisitor(this);

Orm/Xtensive.Orm.SqlServer/Sql.Drivers.SqlServer/v09/Compiler.cs

@@ -179,9 +179,8 @@ public override void Visit(SqlFunctionCall node)
           return;
         case SqlFunctionType.Substring:
           if (node.Arguments.Count == 2) {
-            node = SqlDml.Substring(node.Arguments[0], node.Arguments[1]);
             SqlExpression len = SqlDml.CharLength(node.Arguments[0]);
-            node.Arguments.Add(len);
+            node = SqlDml.Substring(node.Arguments[0], node.Arguments[1], len);
             Visit(node);
             return;
           }

Orm/Xtensive.Orm/Core/ArgumentValidator.cs

@@ -91,13 +91,16 @@ public static void EnsureArgumentNotNullOrEmptyOrWhiteSpace(string value, [Invok
     /// <param name="value">Value to compare check.</param>
     /// <param name="parameterName">Name of the method parameter.</param>
     /// <typeparam name="T">The expected type of value.</typeparam>
+    /// <returns><paramref name="value" /> parameter casted to type <typeparamref name="T" /></returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static void EnsureArgumentIs<T>(object value, [InvokerParameterName] string parameterName)
+    public static T EnsureArgumentIs<T>(object value,
+      [InvokerParameterName, CallerArgumentExpression("value")] string parameterName = null)
     {
-      EnsureArgumentNotNull(value, parameterName);
-      if (!(value is T)) {
-        throw new ArgumentException(string.Format(Strings.ExInvalidArgumentType, typeof(T)), parameterName);
+      if (value is T result) {
+        return result;
       }
+      EnsureArgumentNotNull(value, parameterName);
+      throw new ArgumentException(string.Format(Strings.ExInvalidArgumentType, typeof(T)), parameterName);
     }
 
     /// <summary>

Orm/Xtensive.Orm/Modelling/Nesting.cs

@@ -81,7 +81,7 @@ internal Nesting(Node node, string propertyName)
 
     internal Nesting(Node node)
     {
-      ArgumentValidator.EnsureArgumentIs<IModel>(node, "node");
+      _ = ArgumentValidator.EnsureArgumentIs<IModel>(node);
       Node = node;
       Initialize();
     }

Orm/Xtensive.Orm/Modelling/Node.cs

@@ -433,8 +433,7 @@ protected virtual void ValidateMove(Node newParent, string newName, int newIndex
       }
 
       // Validating parent model
-      ArgumentValidator.EnsureArgumentNotNull(newParent, nameof(newParent));
-      ArgumentValidator.EnsureArgumentIs<Node>(newParent, nameof(newParent));
+      _ = ArgumentValidator.EnsureArgumentIs<Node>(newParent);
       var model = Model;
       if (model != null) {
         var newModel = newParent.Model;

Orm/Xtensive.Orm/Sql/Dml/Expressions/SqlAggregate.cs

@@ -33,9 +33,7 @@ public SqlExpression Expression
 
     public override void ReplaceWith(SqlExpression expression)
     {
-      ArgumentValidator.EnsureArgumentNotNull(expression, "expression");
-      ArgumentValidator.EnsureArgumentIs<SqlAggregate>(expression, "expression");
-      var replacingExpression = (SqlAggregate) expression;
+      var replacingExpression = ArgumentValidator.EnsureArgumentIs<SqlAggregate>(expression);
       NodeType = replacingExpression.NodeType;
       distinct = replacingExpression.Distinct;
       this.expression = replacingExpression.Expression;

Orm/Xtensive.Orm/Sql/Dml/Expressions/SqlArray{T}.cs

@@ -37,9 +37,7 @@ public static implicit operator SqlArray<T>(T[] value)
 
     public override void ReplaceWith(SqlExpression expression)
     {
-      ArgumentValidator.EnsureArgumentNotNull(expression, "expression");
-      ArgumentValidator.EnsureArgumentIs<SqlArray<T>>(expression, "expression");
-      var replacingExpression = (SqlArray<T>) expression;
+      var replacingExpression = ArgumentValidator.EnsureArgumentIs<SqlArray<T>>(expression);
       Values = replacingExpression.Values;
     }
 

Orm/Xtensive.Orm/Sql/Dml/Expressions/SqlBetween.cs

@@ -46,9 +46,7 @@ public SqlExpression Expression
 
     public override void ReplaceWith(SqlExpression expression)
     {
-      ArgumentValidator.EnsureArgumentNotNull(expression, "expression");
-      ArgumentValidator.EnsureArgumentIs<SqlBetween>(expression, "expression");
-      SqlBetween replacingExpression = expression as SqlBetween;
+      var replacingExpression = ArgumentValidator.EnsureArgumentIs<SqlBetween>(expression);
       NodeType = replacingExpression.NodeType;
       left = replacingExpression.Left;
       right = replacingExpression.Right;

Orm/Xtensive.Orm/Sql/Dml/Expressions/SqlBinary.cs

@@ -83,9 +83,7 @@ public static bool operator false(SqlBinary operand)
 
     public override void ReplaceWith(SqlExpression expression)
     {
-      ArgumentValidator.EnsureArgumentNotNull(expression, "expression");
-      ArgumentValidator.EnsureArgumentIs<SqlBinary>(expression, "expression");
-      var replacingExpression = (SqlBinary) expression;
+      var replacingExpression = ArgumentValidator.EnsureArgumentIs<SqlBinary>(expression);
       NodeType = replacingExpression.NodeType;
       Left = replacingExpression.Left;
       Right = replacingExpression.Right;