/// <summary>
/// 访问 <see cref="BatchCommandExpression"/> 表达式。
/// </summary>
/// <param name="batch"></param>
/// <returns></returns>
protected override Expression VisitBatch(BatchCommandExpression batch)
{
_isAsync = _isAsync || batch.IsAsync;
var operation = batch.Operation;
if (operation.Body is InsertCommandExpression insert)
{
if (batch.Arguments.Count == 0)
{
return(_isAsync ? Expression.Constant(Task.FromResult(-1)) : Expression.Constant(-1));
}
var rewriter = insert.Update(insert.Table, VisitColumnAssignments(insert.Assignments));
if (rewriter != insert)
{
operation = Expression.Lambda(rewriter, operation.Parameters.ToArray());
}
}
batch = batch.Update(batch.Input, operation, batch.Arguments);
return(BuildExecuteBatch(batch));
}
/// <summary>
/// 浏览 <see cref="BatchCommandExpression"/> 表达式。
/// </summary>
/// <param name="batch"></param>
/// <returns></returns>
protected override Expression VisitBatch(BatchCommandExpression batch)
{
if (batch.Arguments.Count == 0)
{
return(Expression.Constant(-1));
}
var operation = batch.Operation;
if (operation.Body is CommandExpression command)
{
if (command.NodeType == DbExpressionType.Insert)
{
var insert = command as InsertCommandExpression;
var rewriter = insert.Update(insert.Table, VisitColumnAssignments(insert.Assignments));
if (rewriter != insert)
{
operation = Expression.Lambda(rewriter, operation.Parameters.ToArray());
}
}
}
batch = batch.Update(batch.Input, operation, batch.Arguments);
return(BuildExecuteBatch(batch));
}
private Expression BuildExecuteBatch(BatchCommandExpression batch)
{
var operation = Parameterize(batch.Operation.Body);
var result = translator(operation);
var namedValues = NamedValueGatherer.Gather(operation);
var table = new DataTable();
foreach (var nv in namedValues)
{
var info = GetPropertyInfoFromExpression(nv.Value);
table.Columns.Add(nv.Name, info.DataType.Value.FromDbType());
}
var parameters = namedValues.ToDictionary(s => s.Name, s =>
{
var expression = s.Value;
if (ConvertManager.GetConverter(expression.Type) != null)
{
var info = GetPropertyInfoFromExpression(expression);
var convExp = Expression.Call(null, MthGetConverter, Expression.Constant(expression.Type));
expression = Expression.Call(convExp, MthConvertTo, expression, Expression.Constant((DbType)info.DataType));
}
var lambda = Expression.Lambda(expression, batch.Operation.Parameters[1]).Compile();
return(lambda);
});
var entities = (IEnumerable)((ConstantExpression)batch.Input).Value;
foreach (IEntity entity in entities)
{
var row = table.NewRow();
foreach (var nv in parameters)
{
row[nv.Key] = nv.Value.DynamicInvoke(entity) ?? DBNull.Value;
}
table.Rows.Add(row);
}
Expression plan = Expression.Call(executor, MthUpdate,
Expression.Constant(table),
Expression.Constant((SqlCommand)result.QueryText),
Expression.Constant(null, typeof(SqlCommand)),
Expression.Constant(null, typeof(SqlCommand))
);
if (operation.NodeType != (ExpressionType)DbExpressionType.Insert)
{
return(plan);
}
return(Expression.Call(typeof(ExecutionBuilder), nameof(ExecutionBuilder.UpdateEntities), null,
plan,
Expression.Constant(table, typeof(DataTable)),
Expression.Constant(entities, typeof(IEnumerable))));
}
private Expression BuildExecuteBatch(BatchCommandExpression batch)
{
var operation = Parameterize(batch.Operation.Body);
var result = translator(operation);
var namedValues = NamedValueGatherer.Gather(operation);
var table = new DataTable();
foreach (var nv in namedValues)
{
var t = nv.Type.GetNonNullableType();
if (t.IsEnum)
{
t = typeof(int);
}
table.Columns.Add(nv.Name, t);
}
var parameters = namedValues.ToDictionary(s => s.Name, s => Expression.Lambda(s.Value, batch.Operation.Parameters[1]).Compile());
var entities = (IEnumerable)((ConstantExpression)batch.Input).Value;
foreach (IEntity entity in entities)
{
var row = table.NewRow();
foreach (var nv in parameters)
{
row[nv.Key] = nv.Value.DynamicInvoke(entity) ?? DBNull.Value;
}
table.Rows.Add(row);
}
Expression plan = Expression.Call(executor, MthUpdate,
Expression.Constant(table),
Expression.Constant((SqlCommand)result.QueryText),
Expression.Constant(null, typeof(SqlCommand)),
Expression.Constant(null, typeof(SqlCommand))
);
if (operation.NodeType != (ExpressionType)DbExpressionType.Insert)
{
return(plan);
}
return(Expression.Call(typeof(ExecutionBuilder), nameof(ExecutionBuilder.UpdateEntities), null,
plan,
Expression.Constant(table, typeof(DataTable)),
Expression.Constant(entities, typeof(IEnumerable))));
}
protected override Expression VisitBatch(BatchCommandExpression batch)
{
var operation = batch.Operation;
var command = operation.Body as CommandExpression;
if (command != null)
{
if (command.NodeType == DbExpressionType.Insert)
{
var insert = command as InsertCommandExpression;
var rewriter = insert.Update(insert.Table, VisitColumnAssignments(insert.Assignments));
if (rewriter != insert)
{
operation = LambdaExpression.Lambda(rewriter, operation.Parameters.ToArray());
}
}
}
batch = batch.Update(batch.Input, operation);
return(BuildExecuteBatch(batch));
}
private Expression BuildExecuteBatch(BatchCommandExpression batch)
{
var operation = Parameterize(batch.Operation.Body);
var result = _translator.Translate(operation);
var namedValues = NamedValueGatherer.Gather(operation);
var table = new DataTable();
foreach (var nv in namedValues)
{
var info = GetPropertyInfoFromExpression(nv.Value);
if (info != null)
{
table.Columns.Add(nv.Name, info.DataType.Value.FromDbType());
}
else
{
table.Columns.Add(nv.Name, DataExpressionRow.CreateType(nv.Value.Type));
}
}
var parameters = namedValues.ToDictionary(s => s.Name, s =>
{
var expression = s.Value;
var info = GetPropertyInfoFromExpression(expression);
if (info == null)
{
return(expression);
}
if (ConvertManager.GetConverter(expression.Type) != null)
{
var convExp = Expression.Call(null, MethodCache.GetConverter, Expression.Constant(expression.Type));
expression = Expression.Call(convExp, MethodCache.ConvertTo, expression, Expression.Constant((DbType)info.DataType));
}
return((object)Expression.Lambda(expression, batch.Operation.Parameters[1]).Compile());
});
var entities = (IEnumerable)batch.Input.Value;
foreach (IEntity entity in entities)
{
var row = table.NewRow();
foreach (var nv in parameters)
{
if (nv.Value is Delegate del)
{
row[nv.Key] = del.DynamicInvoke(entity) ?? DBNull.Value;
}
else if (nv.Value is Expression exp)
{
exp = ParameterRewriter.Rewrite(exp, batch.Operation.Parameters[1], entity);
var setter = Expression.Lambda(exp, _executor).Compile();
row[nv.Key] = DataExpressionRow.Create(exp.Type, setter);
}
}
table.Rows.Add(row);
}
Expression plan;
if (_isAsync)
{
_cancelToken = Expression.Parameter(typeof(CancellationToken), "token");
plan = Expression.Call(_executor, MethodCache.DbUpdateAsync,
Expression.Constant(table),
Expression.Constant((SqlCommand)result.QueryText),
Expression.Constant(null, typeof(SqlCommand)),
Expression.Constant(null, typeof(SqlCommand)),
_cancelToken
);
}
else
{
plan = Expression.Call(_executor, MethodCache.DbUpdate,
Expression.Constant(table),
Expression.Constant((SqlCommand)result.QueryText),
Expression.Constant(null, typeof(SqlCommand)),
Expression.Constant(null, typeof(SqlCommand))
);
}
if (operation.NodeType != (ExpressionType)DbExpressionType.Insert)
{
return(plan);
}
return(Expression.Call(typeof(ExecutionBuilder),
_isAsync ? nameof(ExecutionBuilder.UpdateEntitiesAsync) : nameof(ExecutionBuilder.UpdateEntities), null,
plan,
Expression.Constant(table, typeof(DataTable)),
Expression.Constant(entities, typeof(IEnumerable))));
}
