public void ExecuteReader(IDbCommandStruct commandStruct, Action <IDataReader> readProcessor)
{
if (commandStruct == null)
{
throw new ArgumentNullException(nameof(commandStruct));
}
if (readProcessor == null)
{
throw new ArgumentNullException(nameof(readProcessor));
}
var dbConnection = Allocate();
try
{
dbConnection.EnsureConnection();
using (var reader = dbConnection.ExecuteReader(commandStruct.CommandText, CommandType.Text, commandStruct.CommandTimeout, commandStruct.Parameters))
{
readProcessor(reader);
}
}
finally
{
Release(dbConnection);
}
}
public static void Where <T>(this IDbCommandStruct @struct, Expression <Func <T, bool> > expression)
{
if (@struct == null)
{
throw new ArgumentNullException(nameof(@struct));
}
if (expression == null)
{
throw new ArgumentNullException(nameof(expression));
}
int pIndex = 0;
@struct.Condition = Accept(@struct, expression.Body, ref pIndex);
}
public int ExecuteNonQuery(IDbCommandStruct commandStruct)
{
if (commandStruct == null)
{
throw new ArgumentNullException(nameof(commandStruct));
}
var dbConnection = Allocate();
try
{
dbConnection.EnsureConnection();
return(dbConnection.ExecuteNonQuery(commandStruct.CommandText, CommandType.Text, commandStruct.CommandTimeout, commandStruct.Parameters));
}
finally
{
Release(dbConnection);
}
}
public static List <T> Load <T>(IDbCommandStruct <T> commandStruct)
where T : RowAdapter, new()
{
if (commandStruct == null)
{
throw new ArgumentNullException(nameof(commandStruct));
}
if (!EntitySchemaManager.TryGetSchema <T>(out IEntitySchema view))
{
throw new ArgumentException(string.Format("not found {0}:{1}", nameof(IEntitySchema), typeof(T).FullName));
}
if (!DbConnectionManager.TryGet(view.ConnectKey, out DbConnectionProvider connectionProvider))
{
throw new InvalidOperationException("not found DbProvider:" + view.ConnectKey);
}
return(Load <T>(connectionProvider, commandStruct));
}
public static List <T> Load <T>(IDbProvider dbProvider, IDbCommandStruct commandStruct)
where T : RowAdapter, new()
{
if (dbProvider == null)
{
throw new ArgumentNullException(nameof(dbProvider));
}
if (commandStruct == null)
{
throw new ArgumentNullException(nameof(commandStruct));
}
var rows = DbHelper.Load <T>(dbProvider, commandStruct);
foreach (var row in rows)
{
row.saveUsage = SaveUsage.Update;
row.Initialize();
}
return(rows);
}
public static List <T> Load <T>(DbConnectionProvider connectionProvider, IDbCommandStruct <T> commandStruct)
where T : RowAdapter, new()
{
if (connectionProvider == null)
{
throw new ArgumentNullException(nameof(connectionProvider));
}
if (commandStruct == null)
{
throw new ArgumentNullException(nameof(commandStruct));
}
var rows = connectionProvider.Select <T>(commandStruct);
foreach (var row in rows)
{
row._saveUsage = SaveUsage.Update;
row.Initialize();
}
return(rows);
}
public static void GroupBy <T>(this IDbCommandStruct @struct, Expression <Func <T, object> > expression)
{
if (@struct == null)
{
throw new ArgumentNullException(nameof(@struct));
}
if (expression == null)
{
throw new ArgumentNullException(nameof(expression));
}
MemberExpression memberExpression;
switch (expression.Body)
{
case MemberExpression other:
memberExpression = other;
break;
case UnaryExpression other:
if (other.NodeType == ExpressionType.Convert && other.Operand is MemberExpression m)
{
memberExpression = m;
break;
}
throw new InvalidOperationException("invalid expression");
default:
throw new InvalidOperationException("invalid expression");
}
var groups = @struct.Groups?.ToList() ?? new List <SqlMemberExpression>();
groups.Add(SqlExpression.Member(memberExpression.Member.Name));
@struct.Groups = groups.ToArray();
}
public static void OrderBy <T>(this IDbCommandStruct @struct, Expression <Func <T, object> > expression, bool ascending = true)
{
if (@struct == null)
{
throw new ArgumentNullException(nameof(@struct));
}
if (expression == null)
{
throw new ArgumentNullException(nameof(expression));
}
MemberExpression memberExpression;
switch (expression.Body)
{
case MemberExpression other:
memberExpression = other;
break;
case UnaryExpression other:
if (other.NodeType == ExpressionType.Convert && other.Operand is MemberExpression m)
{
memberExpression = m;
break;
}
throw new InvalidOperationException("invalid expression");
default:
throw new InvalidOperationException("invalid expression");
}
var sortOrders = @struct.SortOrders?.ToList() ?? new List <IDbSortClause>();
sortOrders.Add(new DbSortClause(SqlExpression.Member(memberExpression.Member.Name), ascending));
@struct.SortOrders = sortOrders.ToArray();
}
public static List <T> Select <T>(this DbConnectionProvider connectionProvider, IDbCommandStruct commandStruct)
{
if (commandStruct == null)
{
throw new ArgumentNullException(nameof(commandStruct));
}
return(Select <T>(connectionProvider, commandStruct.CommandText, CommandType.Text, commandStruct.CommandTimeout, commandStruct.Parameters));
}
private static SqlExpression Accept(IDbCommandStruct @struct, Expression expression, ref int pIndex)
{
if (expression is BinaryExpression binary)
{
SqlExpression lexpre = Accept(@struct, binary.Left, ref pIndex);
SqlExpression rexpre = Accept(@struct, binary.Right, ref pIndex);
switch (binary.NodeType)
{
case ExpressionType.AndAlso:
return(SqlExpression.And(lexpre, rexpre));
case ExpressionType.OrElse:
return(SqlExpression.Or(lexpre, rexpre));
case ExpressionType.GreaterThan:
return(SqlExpression.GreaterThan(lexpre, rexpre));
case ExpressionType.GreaterThanOrEqual:
return(SqlExpression.GreaterThanOrEqual(lexpre, rexpre));
case ExpressionType.Equal:
switch (rexpre)
{
case SqlConstantExpression constant when constant.Value is null:
return(SqlExpression.Is(lexpre, rexpre));
default:
return(SqlExpression.Equal(lexpre, rexpre));
}
case ExpressionType.NotEqual:
switch (rexpre)
{
case SqlConstantExpression constant when constant.Value is null:
return(SqlExpression.Not(SqlExpression.Is(lexpre, rexpre)));
default:
return(SqlExpression.NotEqual(lexpre, rexpre));
}
case ExpressionType.LessThanOrEqual:
return(SqlExpression.LessThanOrEqual(lexpre, rexpre));
case ExpressionType.LessThan:
return(SqlExpression.LessThan(lexpre, rexpre));
default:
throw new ArgumentException(nameof(binary.NodeType));
}
}
else if (expression is MemberExpression member)
{
if (member.Expression.NodeType == ExpressionType.Parameter)
{
return(SqlExpression.Member(member.Member.Name));
}
else
{
var name = "var" + pIndex++;
var parent = member.Expression?.GetValue();
var value = member.Member.GetValue(parent);
@struct.AddParameter(name, value);
return(SqlExpression.Paramter(name));
}
}
else if (expression is UnaryExpression unary)
{
var node = Accept(@struct, unary.Operand, ref pIndex);
if (unary.NodeType == ExpressionType.Not)
{
return(SqlExpression.Not(node));
}
else if (unary.NodeType == ExpressionType.Negate)
{
return(SqlExpression.Negate(node));
}
else if (unary.NodeType == ExpressionType.Convert)
{
return(node);
}
else
{
throw new ArgumentException();
}
}
else if (expression is ConstantExpression constant)
{
if (constant.Value == null)
{
return(SqlExpression.Constant(null));
}
var name = "var" + pIndex++;
@struct.AddParameter(name, constant.Value);
return(SqlExpression.Paramter(name));
}
else if (expression is NewExpression newexpr)
{
var objParams = new object[newexpr.Arguments.Count];
for (int i = 0; i < objParams.Length; i++)
{
objParams[i] = newexpr.Arguments[i].GetValue();
}
var obj = newexpr.Constructor.Invoke(objParams);
return(SqlExpression.Constant(obj));
}
else if (expression is MethodCallExpression methodCall)
{
if (methodCall.Method.Name == "Contains" && methodCall.Method.ReturnType == typeof(bool) && methodCall.Arguments.Count == 1)
{
var parameters = methodCall.Method.GetParameters();
if (parameters.Length == 1)
{
var collection = GetValue(methodCall.Object) as IEnumerable;
var expressions = new List <SqlExpression>();
foreach (var value in collection)
{
expressions.Add(SqlExpression.Constant(value));
}
int inIndex = 0;
var argument = Accept(@struct, methodCall.Arguments[0], ref inIndex);
var newArray = SqlExpression.NewArray(expressions);
return(SqlExpression.In(argument, newArray));
}
}
}
throw new ArgumentException();
}
