Skip to content

Commit 846cb56

Browse files
SebastianStehleSebastianStehle
committed
Just some minor performance improvements.
1 parent d16e579 commit 846cb56

1 file changed

Lines changed: 79 additions & 69 deletions

File tree

‎src/PhenX.EntityFrameworkCore.BulkInsert/Dialect/SqlDialectBuilder.cs‎

Lines changed: 79 additions & 69 deletions
Original file line numberDiff line numberDiff line change
@@ -138,16 +138,17 @@ protected virtual string GetExcludedColumnName(string columnName)
138138
/// <summary>
139139
/// Quotes a column name using database-specific delimiters.
140140
/// </summary>
141-
public string Quote(string entity) => $"{OpenDelimiter}{entity}{CloseDelimiter}";
141+
public string Quote(string entity)
142+
{
143+
return $"{OpenDelimiter}{entity}{CloseDelimiter}";
144+
}
142145

143146
/// <summary>
144147
/// Quotes a schema and table name using database-specific delimiters.
145148
/// </summary>
146149
public string QuoteTableName(string? schema, string tableName)
147150
{
148-
return schema != null
149-
? $"{Quote(schema)}.{Quote(tableName)}"
150-
: Quote(tableName);
151+
return schema != null ? $"{Quote(schema)}.{Quote(tableName)}" : Quote(tableName);
151152
}
152153

153154
/// <summary>
@@ -157,12 +158,11 @@ protected string[] GetColumns<T>(TableMetadata table, Expression<Func<T, object>
157158
{
158159
return columns.Body switch
159160
{
160-
NewExpression newExpression => newExpression.Arguments.OfType<MemberExpression>()
161-
.Select(m => table.GetQuotedColumnName(m.Member.Name))
162-
.ToArray(),
163-
MemberExpression memberExpression => [
164-
table.GetQuotedColumnName(memberExpression.Member.Name)
165-
],
161+
NewExpression newExpression =>
162+
newExpression.Arguments.OfType<MemberExpression>()
163+
.Select(m => table.GetQuotedColumnName(m.Member.Name)).ToArray(),
164+
MemberExpression memberExpression =>
165+
[table.GetQuotedColumnName(memberExpression.Member.Name)],
166166
_ => throw new NotSupportedException("Unsupported expression type")
167167
};
168168
}
@@ -228,85 +228,95 @@ private string ToSqlExpression<TEntity>(TableMetadata table, Expression expr)
228228
{
229229
switch (expr)
230230
{
231-
case MemberExpression m:
232-
return GetExcludedColumnName(table.GetColumnName(m.Member.Name));
231+
case MemberExpression memberExpr:
232+
return GetExcludedColumnName(table.GetColumnName(memberExpr.Member.Name));
233233

234-
case BinaryExpression b:
235-
var left = ToSqlExpression<TEntity>(table, b.Left);
236-
var right = ToSqlExpression<TEntity>(table, b.Right);
237-
var op = b.NodeType switch
234+
case BinaryExpression binaryExpr:
238235
{
239-
ExpressionType.Add => b.Type == typeof(string) ? ConcatOperator : "+",
240-
ExpressionType.Subtract => "-",
241-
ExpressionType.Multiply => "*",
242-
ExpressionType.Divide => "/",
243-
ExpressionType.Modulo => "%",
244-
ExpressionType.AndAlso => "AND",
245-
ExpressionType.OrElse => "OR",
246-
ExpressionType.Equal => "=",
247-
ExpressionType.NotEqual => "<>",
248-
ExpressionType.LessThan => "<",
249-
ExpressionType.LessThanOrEqual => "<=",
250-
ExpressionType.GreaterThan => ">",
251-
ExpressionType.GreaterThanOrEqual => ">=",
252-
_ => throw new NotSupportedException($"Unsupported operator: {b.NodeType}")
253-
};
254-
return $"({left} {op} {right})";
255-
256-
case ConstantExpression c:
257-
if (c.Type == typeof(RawSqlValue) && c.Value != null)
236+
var op = binaryExpr.NodeType switch
237+
{
238+
ExpressionType.Add => binaryExpr.Type == typeof(string) ? ConcatOperator : "+",
239+
ExpressionType.Subtract => "-",
240+
ExpressionType.Multiply => "*",
241+
ExpressionType.Divide => "/",
242+
ExpressionType.Modulo => "%",
243+
ExpressionType.AndAlso => "AND",
244+
ExpressionType.OrElse => "OR",
245+
ExpressionType.Equal => "=",
246+
ExpressionType.NotEqual => "<>",
247+
ExpressionType.LessThan => "<",
248+
ExpressionType.LessThanOrEqual => "<=",
249+
ExpressionType.GreaterThan => ">",
250+
ExpressionType.GreaterThanOrEqual => ">=",
251+
_ => throw new NotSupportedException($"Unsupported operator: {binaryExpr.NodeType}")
252+
};
253+
254+
var lhs = ToSqlExpression<TEntity>(table, binaryExpr.Left);
255+
var rhs = ToSqlExpression<TEntity>(table, binaryExpr.Right);
256+
257+
return $"({lhs} {op} {rhs})";
258+
}
259+
260+
case ConstantExpression contantExpr:
261+
if (contantExpr.Type == typeof(RawSqlValue) && contantExpr.Value != null)
258262
{
259-
return ((RawSqlValue)c.Value!).Sql;
263+
return ((RawSqlValue)contantExpr.Value!).Sql;
260264
}
261265

262-
if (c.Type == typeof(string) ||
263-
c.Type == typeof(Guid))
266+
if (contantExpr.Type == typeof(string) ||
267+
contantExpr.Type == typeof(Guid))
264268
{
265-
return $"'{c.Value}'";
269+
return $"'{contantExpr.Value}'";
266270
}
267271

268-
if (c.Type == typeof(bool))
272+
if (contantExpr.Type == typeof(bool))
269273
{
270-
return (bool)c.Value! ? "TRUE" : "FALSE";
274+
return (bool)contantExpr.Value! ? "TRUE" : "FALSE";
271275
}
272276

273-
return c.Value?.ToString() ?? "NULL";
277+
return contantExpr.Value?.ToString() ?? "NULL";
274278

275-
case UnaryExpression u:
276-
if (u.NodeType == ExpressionType.Convert)
279+
case UnaryExpression unaryExpr:
280+
if (unaryExpr.NodeType == ExpressionType.Convert)
277281
{
278-
return ToSqlExpression<TEntity>(table, u.Operand);
282+
return ToSqlExpression<TEntity>(table, unaryExpr.Operand);
279283
}
280-
if (u.NodeType == ExpressionType.Not)
284+
if (unaryExpr.NodeType == ExpressionType.Not)
281285
{
282-
return $"NOT ({ToSqlExpression<TEntity>(table, u.Operand)})";
286+
return $"NOT ({ToSqlExpression<TEntity>(table, unaryExpr.Operand)})";
283287
}
284-
throw new NotSupportedException($"Unary operator not supported: {u.NodeType}");
288+
throw new NotSupportedException($"Unary operator not supported: {unaryExpr.NodeType}");
285289

286-
case MethodCallExpression mce:
287-
// Supporte quelques méthodes courantes (ToLower, ToUpper, Trim, etc.)
288-
var objSql = mce.Object != null ? ToSqlExpression<TEntity>(table, mce.Object) : null;
289-
var argsSql = mce.Arguments.Select(expr1 => ToSqlExpression<TEntity>(table, expr1)).ToArray();
290-
switch (mce.Method.Name)
290+
case MethodCallExpression methodExpr:
291291
{
292-
case "ToLower":
293-
return $"LOWER({objSql})";
294-
case "ToUpper":
295-
return $"UPPER({objSql})";
296-
case "Trim":
297-
return $"BTRIM({objSql})";
298-
case "Contains" when mce is { Object: not null, Arguments.Count: 1 }:
299-
return $"{objSql} LIKE '%' || {argsSql[0]} || '%'";
300-
case "StartsWith" when mce is { Object: not null, Arguments.Count: 1 }:
301-
return $"{objSql} LIKE {argsSql[0]} || '%'";
302-
case "EndsWith" when mce is { Object: not null, Arguments.Count: 1 }:
303-
return $"{objSql} LIKE '%' || {argsSql[0]}";
304-
default:
305-
throw new NotSupportedException($"Method not supported: {mce.Method.Name}");
292+
var lhs = methodExpr.Object != null ? ToSqlExpression<TEntity>(table, methodExpr.Object) : null;
293+
294+
string Rhs()
295+
{
296+
return ToSqlExpression<TEntity>(table, methodExpr.Arguments[0]);
297+
}
298+
299+
switch (methodExpr.Method.Name)
300+
{
301+
case "ToLower":
302+
return $"LOWER({lhs})";
303+
case "ToUpper":
304+
return $"UPPER({lhs})";
305+
case "Trim":
306+
return $"BTRIM({lhs})";
307+
case "Contains" when methodExpr is { Object: not null, Arguments.Count: 1 }:
308+
return $"{lhs} LIKE '%' || {Rhs()} || '%'";
309+
case "EndsWith" when methodExpr is { Object: not null, Arguments.Count: 1 }:
310+
return $"{lhs} LIKE '%' || {Rhs()}";
311+
case "StartsWith" when methodExpr is { Object: not null, Arguments.Count: 1 }:
312+
return $"{lhs} LIKE {Rhs()} || '%'";
313+
default:
314+
throw new NotSupportedException($"Method not supported: {methodExpr.Method.Name}");
315+
}
306316
}
307317

308-
case ParameterExpression p:
309-
return Quote(p.Name ?? "param");
318+
case ParameterExpression parameterExpr:
319+
return Quote(parameterExpr.Name ?? "param");
310320

311321
default:
312322
throw new NotSupportedException($"Expression not supported: {expr.NodeType}");

0 commit comments

Comments
 (0)