public override TType GetFunction <TType, TModel>(Expression <Func <TModel, bool> > expression, Expression <Func <TModel, TType> > selectField, FunctionType functionType, bool compileSp = false)
{
var query = new MongoDBLambdaQuery <TModel>(dbContext);
var m = selectField.Body as MemberExpression;
var fieldName = m?.Member?.Name;
//query.Select(selectField.Body);
//query.Where(expression);
var collection = _MongoDB.GetCollection <TModel>(query.QueryTableName);
object result = null;
switch (functionType)
{
case FunctionType.COUNT:
result = collection.Find(expression).CountDocuments();
break;
case FunctionType.SUM:
result = getAggregateResult(collection, expression, "sum", fieldName);
break;
case FunctionType.MAX:
result = getAggregateResult(collection, expression, "max", fieldName);
break;
case FunctionType.MIN:
result = getAggregateResult(collection, expression, "min", fieldName);
break;
default:
throw new NotSupportedException("MongoDB不支持的函数:" + functionType);
}
return(ObjectConvert.ConvertObject <TType>(result));
}
Expression <Func <T, bool> > CreateLambdaBinary(CRLExpression expression)
{
var left = expression.Left;
var right = expression.Right;
var creater = new LambdaCreater <T>();
var type = expression.ExpressionType;
var dic = new Dictionary <string, ExpressionHandler>();
dic.Add("Equal", creater.Equal);
dic.Add("NotEqual", creater.NotEqual);
dic.Add("Greater", creater.Greater);
dic.Add("Less", creater.Less);
dic.Add("GreaterThan", creater.GreaterThan);
dic.Add("LessThan", creater.LessThan);
//todo 更多方法解析
if (!dic.ContainsKey(type))
{
throw new CRLException("没有对应的运算方法 " + type);
}
if (left.Type == CRLExpressionType.MethodCall)//按方法运算 如 b.NameSubstring,Indexof(0,1)=="123"
{
//按属性的子方法
var left2 = CreateLambdaMethodCall2(left);
var value = ObjectConvert.ConvertObject(left2.Type, right.Data);
return(dic[type](left2, value));
}
else//按属性运算 如b.Id==1
{
var member = creater.CreatePropertyExpression(left.Data.ToString());
return(dic[type](member, right.Data));
}
}
/// <summary>
/// 指定替换对象返回单个结果
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="sql"></param>
/// <param name="types"></param>
/// <returns></returns>
public override T ExecScalar <T>(string sql, params Type[] types)
{
sql = _DBAdapter.SqlFormat(sql);
var obj = ExecScalar(sql, types);
return(ObjectConvert.ConvertObject <T>(obj));
}
public string Equals(CRLExpression.MethodCallObj methodInfo, ref int parIndex, AddParameHandler addParame)
{
var field = methodInfo.MemberQueryName;
var nodeType = methodInfo.ExpressionType;
var args = methodInfo.Args;
string parName = string.Format("@equalEnum{0}", parIndex);
parIndex += 1;
var args1 = args[0];
if (args1 is ExpressionValueObj)
{
parName = args1.ToString();
}
else
{
args1 = ObjectConvert.ConvertObject(args1.GetType(), args1);
addParame(parName, args1);
}
var operate = ExpressionVisitor.ExpressionTypeCast(nodeType);
return(string.Format("{0}{2}{1}", field, parName, operate));
//if (nodeType == ExpressionType.Equal)
//{
// return string.Format("{0}={1}", field, parName);
//}
//else
//{
// return string.Format("{0}!={1}", field, parName);
//}
}
/// <summary>
/// 设置对象属性值
/// </summary>
/// <param name="obj"></param>
/// <param name="value"></param>
internal void SetValue(object obj, object value)
{
if (value == null)
{
return;
}
if (value is DBNull)
{
return;
}
Type type = value.GetType();
if (propertyInfo.PropertyType != type)
{
if (value is Int32 && propertyInfo.PropertyType == typeof(string))
{
value = value.ToString();
}
}
try
{
//oracle会出现类型转换问题
value = ObjectConvert.ConvertObject(propertyInfo.PropertyType, value);
propertyInfo.SetValue(obj, value, null);
}
catch (Exception ero)
{
throw new Exception(ero.Message + " 在属性" + propertyInfo.Name + " " + propertyInfo.PropertyType);
}
}
/// <summary>
/// 单个插入
/// </summary>
/// <param name="obj"></param>
public override void InsertFromObj <TModel>(TModel obj)
{
var Reflection = ReflectionHelper.GetInfo <TModel>();
CheckTableCreated <TModel>();
var primaryKey = TypeCache.GetTable(obj.GetType()).PrimaryKey;
CheckData(obj);
var index = _DBAdapter.InsertObject(obj);
if (!primaryKey.KeepIdentity)
{
//Reflection.GetAccessor(primaryKey.Name).Set((TModel)obj, index);
index = ObjectConvert.ConvertObject(primaryKey.PropertyType, index);
primaryKey.SetValue(obj, index);
}
ClearParame();
var clone = obj.Clone();
obj.OriginClone = clone as TModel;
//var type = typeof(TModel);
//if (TypeCache.ModelKeyCache.ContainsKey(type))
//{
// string key = TypeCache.ModelKeyCache[type];
// MemoryDataCache.UpdateCacheItem(key, obj);
//}
UpdateCacheItem <TModel>(obj, null, true);
//return index;
}
Expression CreateLambdaBinary(CRLExpression expression)
{
var left = expression.Left;
var right = expression.Right;
Expression exp;
object value;
var type = expression.ExpType;
if (left.Type == CRLExpressionType.MethodCall)//按方法运算 如 b.NameSubstring,Indexof(0,1)=="123"
{
//按属性的子方法
exp = CreateLambdaMethodCall2(left);
value = ObjectConvert.ConvertObject(exp.Type, right.Data);
}
else if (left.Type == CRLExpressionType.Tree)
{
exp = CreateLambdaBinary(left);//todo 暂时在左边
value = right.Data;
//throw new CRLException("不支持的运算 "+ left.ExpressionType);
}
else//按属性运算 如b.Id==1
{
exp = creater.CreatePropertyExpression(left.Data.ToString());
value = right.Data;
}
switch (type)
{
case ExpressionType.Equal:
return(creater.Equal(exp, value));
case ExpressionType.NotEqual:
return(creater.NotEqual(exp, value));
case ExpressionType.GreaterThan:
return(creater.Greater(exp, value));
case ExpressionType.LessThan:
return(creater.Less(exp, value));
case ExpressionType.GreaterThanOrEqual:
return(creater.GreaterThan(exp, value));
case ExpressionType.LessThanOrEqual:
return(creater.LessThan(exp, value));
case ExpressionType.And:
return(creater.And(exp, value));
case ExpressionType.Or:
return(creater.Or(exp, value));
default:
throw new CRLException("没有对应的运算方法 " + type);
}
}
/// <summary>
/// 获取常量表达式，自动转换值的类型
/// </summary>
/// <param name="expression">表达式</param>
/// <param name="value">值</param>
public static ConstantExpression GetConstant(this Expression expression, object value)
{
var memberExpression = expression as MemberExpression;
if (memberExpression == null)
{
return(Expression.Constant(value));
}
value = ObjectConvert.ConvertObject(memberExpression.Type, value);
return(Expression.Constant(value, memberExpression.Type));
}
public string Equals(string field, ExpressionType nodeType, ref int parIndex, AddParameHandler addParame, object[] args)
{
string parName = string.Format("@equalEnum{0}", parIndex);
parIndex += 1;
var obj = args[0];
obj = ObjectConvert.ConvertObject(obj.GetType(), obj);
addParame(parName, obj);
if (nodeType == ExpressionType.Equal)
{
return(string.Format("{0}={1}", field, parName));
}
else
{
return(string.Format("{0}!={1}", field, parName));
}
}
internal override TType GetFunction <TType, TModel>(Expression <Func <TModel, bool> > expression, Expression <Func <TModel, TType> > selectField, FunctionType functionType, bool compileSp = false)
{
var query = new MongoDBLambdaQuery <TModel>(dbContext);
query.Select(selectField.Body);
query.Where(expression);
var collection = _MongoDB.GetCollection <TModel>(query.QueryTableName);
object result = null;
switch (functionType)
{
case FunctionType.COUNT:
result = collection.Count(query.__MongoDBFilter);
break;
default:
throw new NotSupportedException("MongoDB不支持的函数:" + functionType);
}
return(ObjectConvert.ConvertObject <TType>(result));
}
/// <summary>
/// 单个插入
/// </summary>
/// <param name="obj"></param>
public override void InsertFromObj <TModel>(TModel obj)
{
//var Reflection = ReflectionHelper.GetInfo<TModel>();
CheckTableCreated <TModel>();
var primaryKey = TypeCache.GetTable(obj.GetType()).PrimaryKey;
CheckData(obj);
var index = _DBAdapter.InsertObject(dbContext, obj);
if (!primaryKey.KeepIdentity)
{
//Reflection.GetAccessor(primaryKey.Name).Set((TModel)obj, index);
index = ObjectConvert.ConvertObject(primaryKey.PropertyType, index);
primaryKey.SetValue(obj, index);
}
ClearParame();
obj.SetOriginClone();
UpdateCacheItem <TModel>(obj, null, true);
//return index;
}
Expression <Func <T, bool> > CreateLambdaBinary(CRLExpression expression)
{
var left = expression.Left;
var right = expression.Right;
var creater = new LambdaCreater <T>();
var type = expression.ExpressionType;
if (left.Type == CRLExpressionType.MethodCall)//按方法 如 Substring,Indexof
{
var dic = new Dictionary <string, BinaryMethodHandler>();
dic.Add("Equal", creater.Equal);
dic.Add("NotEqual", creater.NotEqual);
dic.Add("Greater", creater.Greater);
dic.Add("Less", creater.Less);
dic.Add("GreaterThan", creater.GreaterThan);
dic.Add("LessThan", creater.LessThan);
if (!dic.ContainsKey(type))
{
throw new Exception("没有对应的运算方法 " + type);
}
var left2 = CreateLambdaMethodCall2(left);
var value = ObjectConvert.ConvertObject(left2.Type, right.Data);
return(dic[type](left2, value));
}
else
{
var dic = new Dictionary <string, BinaryHandler>();
dic.Add("Equal", creater.Equal);
dic.Add("NotEqual", creater.NotEqual);
dic.Add("Greater", creater.Greater);
dic.Add("Less", creater.Less);
dic.Add("GreaterThan", creater.GreaterThan);
dic.Add("LessThan", creater.LessThan);
if (!dic.ContainsKey(type))
{
throw new Exception("没有对应的运算方法 " + type);
}
return(dic[type](left.Data.ToString(), right.Data));
}
}
public override TType GetFunction <TType, TModel>(Expression <Func <TModel, bool> > expression, Expression <Func <TModel, TType> > selectField, FunctionType functionType, bool compileSp = false)
{
var query = new MongoDBLambdaQuery <TModel>(dbContext);
query.Select(selectField.Body);
query.Where(expression);
var collection = _MongoDB.GetCollection <TModel>(query.QueryTableName);
object result = null;
//https://blog.csdn.net/shiyaru1314/article/details/52370478
//https://www.jb51.net/article/113820.htm
//https://blog.csdn.net/u013476435/article/details/81560089
switch (functionType)
{
case FunctionType.COUNT:
result = collection.Count(query.__MongoDBFilter);
break;
default:
throw new NotSupportedException("MongoDB不支持的函数:" + functionType);
}
return(ObjectConvert.ConvertObject <TType>(result));
}
/// <summary>
/// 获取OUT值
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="name"></param>
/// <returns></returns>
public override T GetOutParam <T>(string name)
{
var obj = dbHelper.GetOutParam(name);
return(ObjectConvert.ConvertObject <T>(obj));
}
/// <summary>
/// 指定替换对象返回单个结果
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="sql"></param>
/// <param name="types"></param>
/// <returns></returns>
public override T ExecScalar <T>(string sql, params Type[] types)
{
var obj = ExecScalar(sql, types);
return(ObjectConvert.ConvertObject <T>(obj));
}
/// <summary>
/// 指定替换对象返回单个结果
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="sql"></param>
/// <returns></returns>
public override T ExecScalar <T>(string sql)
{
var obj = ExecScalar(sql);
return(ObjectConvert.ConvertObject <T>(obj));
}
