No extra select wrapping because of TypeId calculated column

Queries of a lot of entities have type Id as constant value column
included to sql query and this cause SELECT ... FROM (SELECT)
queries where outer select just used all the fields from inner select.
For some cases such wrapping was turned off.

Author: alex-kulakov

Extensions/Xtensive.Orm.BulkOperations.Tests/Other.cs

@@ -242,5 +242,34 @@ public void In()
         trx.Complete();
       }
     }
+
+    [Test]
+    public void InWithCombinationWithFieldUsageinUpdate()
+    {
+      using (Session session = Domain.OpenSession())
+      using (TransactionScope trx = session.OpenTransaction()) {
+        var idsToUpdate = new[] { 99, 100, 102 };
+        var prefix = "abc";
+
+        var bar1 = new Bar(session, 100) { Name = "test1", Count = 3 };
+        var bar2 = new Bar(session, 101) { Name = "test2", Count = 4 };
+        var bar3 = new Bar(session, 102) { Name = "test3", Count = 5 };
+        session.SaveChanges();
+
+        var updatedCount =  session.Query.All<Bar>()
+          .Where(b => b.Id.In(IncludeAlgorithm.ComplexCondition, idsToUpdate))
+          .Update(bar => new Bar(session) { Name = prefix + bar.Name });
+        Assert.That(updatedCount, Is.EqualTo(2));
+
+        var all = session.Query.All<Bar>().Where(b=> b.Id == 100 || b.Id == 101 || b.Id == 102).ToList();
+        var updatedEntities = all.Where(b => b.Id.In(idsToUpdate));
+        Assert.That(updatedEntities.All(e => e.Name.StartsWith(prefix)), Is.True);
+
+        var leftEntities = all.Where(b => !b.Id.In(idsToUpdate));
+        Assert.That(leftEntities.All(e => e.Name.StartsWith(prefix)), Is.False);
+
+        trx.Complete();
+      }
+    }
   }
 }

Orm/Xtensive.Orm/Orm/Providers/SqlCompiler.Helpers.cs

@@ -178,6 +178,16 @@ private static bool IsColumnStub(SqlColumn column)
       return false;
     }
 
+    private static bool IsTypeIdColumn(SqlColumn column)
+    {
+      if (column is SqlUserColumn)
+        return (StringComparer.InvariantCultureIgnoreCase.Compare(column.Name, "TypeId") == 0);
+      var cRef = column as SqlColumnRef;
+      if (!ReferenceEquals(null, cRef))
+        return (StringComparer.InvariantCultureIgnoreCase.Compare(column.Name, "TypeId") == 0);
+      return false;
+    }
+
     private static SqlColumnStub ExtractColumnStub(SqlColumn column)
     {
       var columnStub = column as SqlColumnStub;
@@ -211,6 +221,10 @@ private static bool ShouldUseQueryReference(CompilableProvider origin, SqlProvid
         .Where(i => i >= 0)
         .ToList();
       var containsCalculatedColumns = calculatedColumnIndexes.Count > 0;
+      var typeIdIsOnlyCalculatedColumn = (calculatedColumnIndexes.Count == 1)
+        ? IsTypeIdColumn(sourceSelect.Columns[calculatedColumnIndexes[0]])
+        : false;
+
       var rowNumberIsUsed = calculatedColumnIndexes.Count > 0 && sourceSelect.Columns
         .Select((c, i) => new { c, i })
         .Any(a => calculatedColumnIndexes.Contains(a.i) && ExtractUserColumn(a.c).Expression is SqlRowNumber);
@@ -298,7 +312,7 @@ private static bool ShouldUseQueryReference(CompilableProvider origin, SqlProvid
         return orderingOverCalculatedColumn;
       }
 
-      return containsCalculatedColumns || distinctIsUsed || pagingIsUsed || groupByIsUsed;
+      return (containsCalculatedColumns && !typeIdIsOnlyCalculatedColumn) || distinctIsUsed || pagingIsUsed || groupByIsUsed;
     }
 
     private SqlExpression GetOrderByExpression(SqlExpression expression, SortProvider provider, int index)