Skip to content

Commit d30ed32

Browse files
alex-kulakovalex-kulakov
committed
Code-style improvements
1 parent 2fa4fd5 commit d30ed32

File tree

2 files changed

+99
-101
lines changed

2 files changed

+99
-101
lines changed

‎Extensions/Xtensive.Orm.BulkOperations/Internals/Operation.cs‎

Lines changed: 23 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -4,15 +4,12 @@
44

55
using System;
66
using System.Collections.Generic;
7-
using System.Data.Common;
87
using System.Linq;
98
using System.Reflection;
109
using Xtensive.Core;
1110
using Xtensive.Orm.Linq;
12-
using Xtensive.Orm.Model;
1311
using Xtensive.Orm.Providers;
1412
using Xtensive.Orm.Services;
15-
using Xtensive.Sql.Model;
1613
using Xtensive.Sql;
1714
using Xtensive.Sql.Dml;
1815
using QueryParameterBinding = Xtensive.Orm.Services.QueryParameterBinding;
@@ -24,21 +21,24 @@ internal abstract class Operation<T>
2421
where T : class, IEntity
2522
{
2623
private static readonly MethodInfo TranslateQueryMethod = typeof(QueryBuilder).GetMethod("TranslateQuery");
24+
2725
public readonly QueryProvider QueryProvider;
26+
public readonly QueryBuilder QueryBuilder;
2827
public List<QueryParameterBinding> Bindings;
29-
protected DomainHandler DomainHandler;
30-
protected PrimaryIndexMapping[] PrimaryIndexes;
31-
public QueryBuilder QueryBuilder;
32-
public Session Session;
33-
protected TypeInfo TypeInfo;
3428
public SqlTableRef JoinedTableRef;
3529

30+
protected readonly DomainHandler DomainHandler;
31+
protected readonly PrimaryIndexMapping[] PrimaryIndexes;
32+
protected readonly TypeInfo TypeInfo;
33+
34+
public Session Session { get { return QueryBuilder.Session; } }
35+
3636
public int Execute()
3737
{
3838
EnsureTransactionIsStarted();
39-
QueryProvider.Session.SaveChanges();
39+
Session.SaveChanges();
4040
int value = ExecuteInternal();
41-
SessionStateAccessor accessor = DirectStateAccessor.Get(QueryProvider.Session);
41+
var accessor = DirectStateAccessor.Get(Session);
4242
accessor.Invalidate();
4343
return value;
4444
}
@@ -49,45 +49,36 @@ protected void EnsureTransactionIsStarted()
4949
{
5050
var accessor = QueryProvider.Session.Services.Demand<DirectSqlAccessor>();
5151
#pragma warning disable 168
52-
DbTransaction notUsed = accessor.Transaction;
52+
var notUsed = accessor.Transaction;
5353
#pragma warning restore 168
5454
}
5555

5656
protected abstract int ExecuteInternal();
5757

58-
public QueryTranslationResult GetRequest(IQueryable<T> query)
59-
{
60-
return QueryBuilder.TranslateQuery(query);
61-
}
58+
public QueryTranslationResult GetRequest(IQueryable<T> query) => QueryBuilder.TranslateQuery(query);
6259

63-
public QueryTranslationResult GetRequest(Type type, IQueryable query)
64-
{
65-
return
66-
(QueryTranslationResult) TranslateQueryMethod.MakeGenericMethod(type).Invoke(QueryBuilder, new object[] {query});
67-
}
60+
public QueryTranslationResult GetRequest(Type type, IQueryable query) =>
61+
(QueryTranslationResult) TranslateQueryMethod.MakeGenericMethod(type).Invoke(QueryBuilder, new object[] { query });
6862

69-
public TypeInfo GetTypeInfo(Type entityType)
70-
{
71-
return Session.Domain.Model.Hierarchies.SelectMany(a => a.Types).Single(a => a.UnderlyingType==entityType);
72-
}
63+
public TypeInfo GetTypeInfo(Type entityType) =>
64+
Session.Domain.Model.Hierarchies.SelectMany(a => a.Types).Single(a => a.UnderlyingType == entityType);
7365

7466
#endregion
7567

7668
protected Operation(QueryProvider queryProvider)
7769
{
7870
QueryProvider = queryProvider;
79-
Type entityType = typeof (T);
80-
Session = queryProvider.Session;
81-
DomainHandler = Session.Domain.Services.Get<DomainHandler>();
82-
TypeInfo =
83-
queryProvider.Session.Domain.Model.Hierarchies.SelectMany(a => a.Types).Single(
84-
a => a.UnderlyingType==entityType);
85-
var mapping = Session.StorageNode.Mapping;
71+
var entityType = typeof(T);
72+
var session = queryProvider.Session;
73+
DomainHandler = session.Domain.Services.Get<DomainHandler>();
74+
TypeInfo = DomainHandler.Domain.Model.Hierarchies.SelectMany(a => a.Types)
75+
.Single(a => a.UnderlyingType == entityType);
76+
var mapping = session.StorageNode.Mapping;
8677
PrimaryIndexes = TypeInfo.AffectedIndexes
8778
.Where(i => i.IsPrimary)
8879
.Select(i => new PrimaryIndexMapping(i, mapping[i.ReflectedType]))
8980
.ToArray();
90-
QueryBuilder = Session.Services.Get<QueryBuilder>();
81+
QueryBuilder = session.Services.Get<QueryBuilder>();
9182
}
9283

9384
protected QueryCommand ToCommand(SqlStatement statement)

‎Extensions/Xtensive.Orm.BulkOperations/Internals/QueryOperation.cs‎

Lines changed: 76 additions & 69 deletions
Original file line numberDiff line numberDiff line change
@@ -3,6 +3,7 @@
33
using System.Linq;
44
using System.Linq.Expressions;
55
using System.Reflection;
6+
using Xtensive.Core;
67
using Xtensive.Orm.Linq;
78
using Xtensive.Orm.Model;
89
using Xtensive.Orm.Rse;
@@ -14,7 +15,7 @@ namespace Xtensive.Orm.BulkOperations
1415
internal abstract class QueryOperation<T> : Operation<T>
1516
where T : class, IEntity
1617
{
17-
private readonly static MethodInfo inMethod = GetInMethod();
18+
private readonly static MethodInfo InMethod = GetInMethod();
1819
protected IQueryable<T> query;
1920

2021
protected QueryOperation(QueryProvider queryProvider)
@@ -24,55 +25,55 @@ protected QueryOperation(QueryProvider queryProvider)
2425

2526
private static MethodInfo GetInMethod()
2627
{
27-
foreach (var method in typeof (QueryableExtensions).GetMethods().Where(a => string.Equals(a.Name, "In", StringComparison.Ordinal))) {
28+
foreach (var method in typeof(QueryableExtensions).GetMethods().Where(a => string.Equals(a.Name, "In", StringComparison.Ordinal))) {
2829
var parameters = method.GetParameters();
29-
if (parameters.Length == 3 && string.Equals(parameters[2].ParameterType.Name, "IEnumerable`1", StringComparison.Ordinal))
30+
if (parameters.Length == 3 && string.Equals(parameters[2].ParameterType.Name, "IEnumerable`1", StringComparison.Ordinal)) {
3031
return method;
32+
}
3133
}
3234
return null;
3335
}
3436

3537
protected override int ExecuteInternal()
3638
{
37-
Expression e = query.Expression.Visit((MethodCallExpression ex) =>
38-
{
39-
var methodInfo = ex.Method;
40-
//rewrite localCollection.Contains(entity.SomeField) -> entity.SomeField.In(localCollection)
41-
if (methodInfo.DeclaringType == typeof(Enumerable) &&
42-
string.Equals(methodInfo.Name, "Contains", StringComparison.Ordinal) &&
43-
ex.Arguments.Count == 2) {
44-
var localCollection = ex.Arguments[0];//IEnumerable<T>
45-
var valueToCheck = ex.Arguments[1];
46-
var genericInMethod = inMethod.MakeGenericMethod(new[] { valueToCheck.Type });
47-
ex = Expression.Call(genericInMethod, valueToCheck, Expression.Constant(IncludeAlgorithm.ComplexCondition), localCollection);
48-
methodInfo = ex.Method;
49-
}
39+
var e = query.Expression.Visit((MethodCallExpression ex) => {
40+
var methodInfo = ex.Method;
41+
//rewrite localCollection.Contains(entity.SomeField) -> entity.SomeField.In(localCollection)
42+
if (methodInfo.DeclaringType == typeof(Enumerable) &&
43+
string.Equals(methodInfo.Name, "Contains", StringComparison.Ordinal) &&
44+
ex.Arguments.Count == 2) {
45+
var localCollection = ex.Arguments[0];//IEnumerable<T>
46+
var valueToCheck = ex.Arguments[1];
47+
var genericInMethod = InMethod.MakeGenericMethod(new[] { valueToCheck.Type });
48+
ex = Expression.Call(genericInMethod, valueToCheck, Expression.Constant(IncludeAlgorithm.ComplexCondition), localCollection);
49+
methodInfo = ex.Method;
50+
}
5051

51-
if (methodInfo.DeclaringType == typeof(QueryableExtensions) &&
52-
string.Equals(methodInfo.Name, "In", StringComparison.Ordinal) &&
53-
ex.Arguments.Count > 1) {
54-
if (ex.Arguments[1].Type == typeof(IncludeAlgorithm)) {
55-
var algorithm = (IncludeAlgorithm) ex.Arguments[1].Invoke();
56-
if (algorithm == IncludeAlgorithm.TemporaryTable) {
57-
throw new NotSupportedException("IncludeAlgorithm.TemporaryTable is not supported");
58-
}
59-
if (algorithm == IncludeAlgorithm.Auto) {
60-
List<Expression> arguments = ex.Arguments.ToList();
61-
arguments[1] = Expression.Constant(IncludeAlgorithm.ComplexCondition);
62-
ex = Expression.Call(methodInfo, arguments);
63-
}
52+
if (methodInfo.DeclaringType == typeof(QueryableExtensions) &&
53+
string.Equals(methodInfo.Name, "In", StringComparison.Ordinal) &&
54+
ex.Arguments.Count > 1) {
55+
if (ex.Arguments[1].Type == typeof(IncludeAlgorithm)) {
56+
var algorithm = (IncludeAlgorithm) ex.Arguments[1].Invoke();
57+
if (algorithm == IncludeAlgorithm.TemporaryTable) {
58+
throw new NotSupportedException("IncludeAlgorithm.TemporaryTable is not supported");
6459
}
65-
else {
66-
List<Expression> arguments = ex.Arguments.ToList();
67-
arguments.Insert(1, Expression.Constant(IncludeAlgorithm.ComplexCondition));
68-
List<Type> types = methodInfo.GetParameters().Select(a => a.ParameterType).ToList();
69-
types.Insert(1, typeof(IncludeAlgorithm));
70-
ex = Expression.Call(inMethod.MakeGenericMethod(methodInfo.GetGenericArguments()),
71-
arguments.ToArray());
60+
if (algorithm == IncludeAlgorithm.Auto) {
61+
var arguments = ex.Arguments.ToList();
62+
arguments[1] = Expression.Constant(IncludeAlgorithm.ComplexCondition);
63+
ex = Expression.Call(methodInfo, arguments);
7264
}
7365
}
74-
return ex;
75-
});
66+
else {
67+
var arguments = ex.Arguments.ToList();
68+
arguments.Insert(1, Expression.Constant(IncludeAlgorithm.ComplexCondition));
69+
var types = methodInfo.GetParameters().Select(a => a.ParameterType).ToList();
70+
types.Insert(1, typeof(IncludeAlgorithm));
71+
ex = Expression.Call(InMethod.MakeGenericMethod(methodInfo.GetGenericArguments()),
72+
arguments.ToArray());
73+
}
74+
}
75+
return ex;
76+
});
7677
query = QueryProvider.CreateQuery<T>(e);
7778
return 0;
7879
}
@@ -84,10 +85,12 @@ protected override int ExecuteInternal()
8485

8586
protected void Join(SqlQueryStatement statement, SqlSelect select)
8687
{
87-
if (select.HasLimit)
88+
if (select.HasLimit) {
8889
JoinWhenQueryHasLimitation(statement, select);
89-
else
90+
}
91+
else {
9092
JoinWhenQueryHasNoLimitation(statement, select);
93+
}
9194
}
9295

9396
protected abstract void SetStatementFrom(SqlStatement statement, SqlTable from);
@@ -99,39 +102,40 @@ protected void Join(SqlQueryStatement statement, SqlSelect select)
99102

100103
private void JoinWhenQueryHasLimitation(SqlStatement statement, SqlSelect select)
101104
{
102-
if (!SupportsLimitation() && !SupportsJoin())
105+
if (!SupportsLimitation() && !SupportsJoin()) {
103106
throw new NotSupportedException("This provider does not supported limitation of affected rows.");
107+
}
104108

105-
var sqlTableRef = @select.From as SqlTableRef;
106-
if (sqlTableRef!=null) {
109+
if (@select.From is SqlTableRef sqlTableRef) {
107110
SetStatementTable(statement, sqlTableRef);
108111
JoinedTableRef = sqlTableRef;
109112
}
110-
else
113+
else {
111114
sqlTableRef = GetStatementTable(statement);
115+
}
116+
112117
if (SupportsLimitation()) {
113118
SetStatementLimit(statement, select.Limit);
114119
SetStatementWhere(statement, select.Where);
115120
}
116-
else
121+
else {
117122
JoinViaFrom(statement, select);
118-
119-
123+
}
120124
}
121125
private void JoinWhenQueryHasNoLimitation(SqlStatement statement, SqlSelect select)
122126
{
123-
var sqlTableRef = @select.From as SqlTableRef;
124-
if (sqlTableRef!=null) {
127+
if (@select.From is SqlTableRef sqlTableRef) {
125128
SetStatementTable(statement, sqlTableRef);
126129
SetStatementWhere(statement, select.Where);
127130
JoinedTableRef = sqlTableRef;
128131
return;
129132
}
130-
131-
if (SupportsJoin())
133+
if (SupportsJoin()) {
132134
JoinViaFrom(statement, select);
133-
else
135+
}
136+
else {
134137
JoinViaIn(statement, select);
138+
}
135139
}
136140

137141
private void JoinViaIn(SqlStatement statement, SqlSelect @select)
@@ -165,37 +169,40 @@ private void JoinViaFrom(SqlStatement statement, SqlSelect select)
165169
SetStatementFrom(statement, queryRef);
166170
var sqlTableRef = GetStatementTable(statement);
167171
SqlExpression whereExpression = null;
168-
PrimaryIndexMapping indexMapping = PrimaryIndexes[0];
169-
foreach (ColumnInfo columnInfo in indexMapping.PrimaryIndex.KeyColumns.Keys) {
172+
var indexMapping = PrimaryIndexes[0];
173+
foreach (var columnInfo in indexMapping.PrimaryIndex.KeyColumns.Keys) {
170174
var leftColumn = queryRef.Columns[columnInfo.Name];
171-
var rightColumn = sqlTableRef==null ? GetStatementTable(statement).Columns[columnInfo.Name] : sqlTableRef.Columns[columnInfo.Name];
172-
if (leftColumn==null || rightColumn==null)
175+
var rightColumn = sqlTableRef == null
176+
? GetStatementTable(statement).Columns[columnInfo.Name]
177+
: sqlTableRef.Columns[columnInfo.Name];
178+
if (leftColumn == null || rightColumn == null) {
173179
throw new InvalidOperationException("Source query doesn't contain one of key columns of updated table.");
180+
}
174181
var columnEqualityExperssion = SqlDml.Equals(queryRef.Columns[columnInfo.Name], sqlTableRef.Columns[columnInfo.Name]);
175-
if (whereExpression==null)
176-
whereExpression = columnEqualityExperssion;
177-
else
178-
whereExpression = SqlDml.And(whereExpression, columnEqualityExperssion);
182+
whereExpression = whereExpression == null
183+
? columnEqualityExperssion
184+
: SqlDml.And(whereExpression, columnEqualityExperssion);
179185
}
180186
SetStatementWhere(statement, whereExpression);
181187
}
182188

183189
private void JoinViaJoin(SqlStatement statement, SqlSelect @select)
184190
{
185-
PrimaryIndexMapping indexMapping = PrimaryIndexes[0];
186-
SqlTableRef left = SqlDml.TableRef(indexMapping.Table);
187-
SqlQueryRef right = SqlDml.QueryRef(@select);
191+
var indexMapping = PrimaryIndexes[0];
192+
var left = SqlDml.TableRef(indexMapping.Table);
193+
var right = SqlDml.QueryRef(@select);
188194
SqlExpression joinExpression = null;
189-
for (int i = 0; i < indexMapping.PrimaryIndex.KeyColumns.Count; i++)
190-
{
191-
SqlBinary binary = (left.Columns[i] == right.Columns[i]);
192-
if (joinExpression.IsNullReference())
195+
for (var i = 0; i < indexMapping.PrimaryIndex.KeyColumns.Count; i++) {
196+
var binary = (left.Columns[i] == right.Columns[i]);
197+
if (joinExpression.IsNullReference()) {
193198
joinExpression = binary;
194-
else
199+
}
200+
else {
195201
joinExpression &= binary;
202+
}
196203
}
197204
JoinedTableRef = left;
198-
SqlJoinedTable joinedTable = left.InnerJoin(right, joinExpression);
205+
var joinedTable = left.InnerJoin(right, joinExpression);
199206
SetStatementFrom(statement, joinedTable);
200207
}
201208

0 commit comments

Comments
 (0)