public override List <TModel> QueryOrFromCache <TModel>(ILambdaQuery <TModel> iQuery, out string cacheKey)
{
cacheKey = "none";
var query = iQuery as MongoDBLambdaQuery <TModel>;
var collection = GetCollection <TModel>();
long rowNum = 0;
var query2 = collection.Find(query.__MongoDBFilter).Sort(query._MongoDBSort);
if (query.TakeNum > 0)
{
var pageIndex = query.SkipPage - 1;
var pageSize = query.TakeNum;
var skip = pageSize * pageIndex;
if (skip > 0)
{
query2.Skip(skip);
}
query2.Limit(pageSize);
rowNum = collection.Find(query.__MongoDBFilter).CountDocuments();
}
var result = query2.ToList();
if (rowNum == 0)
{
rowNum = result.Count();
}
query.__RowCount = (int)rowNum;
//SetOriginClone(result);
return(result);
}
/// <summary>
/// 按完整查询条件更新
/// </summary>
/// <param name="query"></param>
/// <param name="updateValue">要按字段值更新,需加前辍$ 如 c["UserId"] = "$UserId"</param>
/// <returns></returns>
public int Update(ILambdaQuery <T> query, Dictionary <string, object> updateValue)
{
var db = DBExtend;
var c = new ParameCollection(updateValue);
return(db.Update(query, c));
}
/// <summary>
/// 按完整查询删除
/// </summary>
/// <param name="query"></param>
/// <returns></returns>
public int Delete(ILambdaQuery <T> query)
{
var db = DBExtend;
int n = db.Delete(query as LambdaQuery <T>);
return(n);
}
public override int Delete <T>(ILambdaQuery <T> query1)
{
var query = query1 as MongoDBLambdaQuery <T>;
var collection = GetCollection <T>();
var result = collection.DeleteMany(query.__MongoDBFilter);
return((int)result.DeletedCount);
}
public override dynamic QueryScalar <TModel>(ILambdaQuery <TModel> query)
{
var result = GetDynamicResult(query);
if (result.Count == 0)
{
return(null);
}
var first = result.First() as IDictionary <string, object>;
var keys = first.Keys.ToList();
return(first[keys.First()]);
}
/// <summary>
/// 按完整查询条件更新
/// </summary>
/// <param name="query"></param>
/// <param name="updateValue">要按字段值更新,需加前辍$ 如 c["UserId"] = "$UserId"</param>
/// <returns></returns>
public int Update(ILambdaQuery <T> query, IDictionary updateValue)
{
var db = DBExtend;
var iDic = updateValue as Dictionary <string, object>;
if (iDic == null)
{
throw new CRLException("无法转换为Dictionary<string, object>");
}
var dic = new ParameCollection(iDic);
return(db.Update(query as LambdaQuery <T>, dic));
}
/// <summary>
/// 使用完整的LamadaQuery查询
/// </summary>
/// <typeparam name="TModel"></typeparam>
/// <param name="query"></param>
/// <returns></returns>
public List <TModel> QueryList <TModel>(ILambdaQuery <TModel> query) where TModel : class
{
string key;
var list = QueryOrFromCache <TModel>(query, out key);
list.ForEach(b =>
{
if (b is IModel)
{
(b as IModel).DbContext = dbContext;
}
});
return(list);
}
public override int Update <TModel>(ILambdaQuery <TModel> iQuery, ParameCollection setValue)
{
var query1 = iQuery as MongoDBLambdaQuery <TModel>;
if (query1.__GroupFields != null)
{
throw new Exception("update不支持group查询");
}
if (query1.__Relations != null && query1.__Relations.Count > 1)
{
throw new Exception("update关联不支持多次");
}
if (setValue.Count == 0)
{
throw new ArgumentNullException("更新时发生错误,参数值为空 ParameCollection setValue");
}
var query = query1 as MongoDBLambdaQuery <TModel>;
return(Update(query.__MongoDBFilter, setValue));
}
///// <summary>
///// 按对象差异更新,由主键确定记录
///// </summary>
///// <typeparam name="TModel"></typeparam>
///// <param name="obj"></param>
///// <returns></returns>
//public override int Update<TModel>(TModel obj)
//{
// var c = GetUpdateField(obj);
// if (c.Count == 0)
// {
// return 0;
// //throw new CRLException("更新集合为空");
// }
// var primaryKey = TypeCache.GetTable(obj.GetType()).PrimaryKey;
// var keyValue = primaryKey.GetValue(obj);
// var pName = _DBAdapter.GetParamName("par", "1");
// var where = string.Format("where {0}={1}", _DBAdapter.KeyWordFormat(primaryKey.MapingName), pName);
// AddParam(pName, keyValue);
// int n = Update<TModel>(c, where);
// UpdateCacheItem(obj, c);
// if (n == 0)
// {
// throw new CRLException("更新失败,找不到主键为 " + keyValue + " 的记录");
// }
// obj.CleanChanges();
// return n;
//}
/// <summary>
/// 按完整查询条件进行更新
/// goup语法不支持,其它支持
/// </summary>
/// <typeparam name="TModel"></typeparam>
/// <param name="query"></param>
/// <param name="updateValue"></param>
/// <returns></returns>
public override int Update <TModel>(ILambdaQuery <TModel> query, ParameCollection updateValue)
{
var query1 = query as RelationLambdaQuery <TModel>;
if (query1.__GroupFields != null)
{
throw new Exception("update不支持group查询");
}
if (query1.__Relations != null && query1.__Relations.Count > 1)
{
throw new Exception("update关联不支持多次");
}
if (updateValue.Count == 0)
{
throw new ArgumentNullException("更新时发生错误,参数值为空 ParameCollection setValue");
}
var sb = new StringBuilder();
query1.GetQueryConditions(sb, false);
var conditions = sb.ToString().Trim();
query1.FillParames(this);
if (query1.__Relations != null)
{
var kv = query1.__Relations.First();
string setString = ForamtSetValue <TModel>(updateValue, kv.Key.OriginType);
var t1 = query1.QueryTableName;
var t2 = TypeCache.GetTableName(kv.Key.OriginType, query1.__DbContext);
string sql = _DBAdapter.GetRelationUpdateSql(t1, t2, conditions, setString, query1);
return(Execute(sql));
}
else
{
conditions = conditions.Replace("t1.", "");
}
return(Update <TModel>(updateValue, conditions));
}
///// <summary>
///// 按主键删除
///// </summary>
///// <typeparam name="TModel"></typeparam>
///// <param name="id"></param>
///// <returns></returns>
//public override int Delete<TModel>(object id)
//{
// var type = typeof(TModel);
// var table = TypeCache.GetTable(type);
// var pName = _DBAdapter.GetParamName("par", "1");
// var where = string.Format("where {0}={1}", _DBAdapter.KeyWordFormat(table.PrimaryKey.MapingName), pName);
// AddParam(pName, id);
// return Delete<TModel>(where);
// //var expression = Base.GetQueryIdExpression<TModel>(id);
// //return Delete<TModel>(expression);
//}
///// <summary>
///// 指定条件删除
///// </summary>
///// <typeparam name="TModel"></typeparam>
///// <param name="expression"></param>
///// <returns></returns>
//public override int Delete<TModel>(Expression<Func<TModel, bool>> expression)
//{
// LambdaQuery<TModel> query = new RelationLambdaQuery<TModel>(dbContext, false);
// query.Where(expression);
// string condition = query.FormatExpression(expression.Body).SqlOut;
// if(!string.IsNullOrEmpty(condition))
// {
// condition = "where " + condition;
// }
// query.FillParames(this);
// return Delete<TModel>(condition);
//}
///// <summary>
///// 关联删除
///// </summary>
///// <typeparam name="TModel"></typeparam>
///// <typeparam name="TJoin"></typeparam>
///// <param name="expression"></param>
///// <returns></returns>
//public override int Delete<TModel, TJoin>(Expression<Func<TModel, TJoin, bool>> expression)
//{
// var query = new RelationLambdaQuery<TModel>(dbContext);
// query.Join<TJoin>(expression);
// return Delete(query);
//}
/// <summary>
/// 按完整查询条件进行删除
/// goup语法不支持,其它支持
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="query"></param>
/// <returns></returns>
public override int Delete <T>(ILambdaQuery <T> query)
{
var query1 = query as RelationLambdaQuery <T>;
if (query1.__GroupFields != null)
{
throw new Exception("delete不支持group查询");
}
if (query1.__Relations != null && query1.__Relations.Count > 1)
{
throw new Exception("delete关联不支持多次");
}
//query1._IsRelationUpdate = true;
var sb = new StringBuilder();
query1.GetQueryConditions(sb, false);
var conditions = sb.ToString();
//conditions = conditions.Substring(5);
string table = query1.QueryTableName;
table = _DBAdapter.KeyWordFormat(table);
query1.FillParames(this);
if (query1.__Relations != null)
{
var kv = query1.__Relations.First();
var t1 = query1.QueryTableName;
var t2 = TypeCache.GetTableName(kv.Key.OriginType, query1.__DbContext);
//var join = kv.Value;
//join = join.Substring(join.IndexOf(" on ") + 3);
//if (!string.IsNullOrEmpty(conditions))
//{
// join += " and ";
//}
string sql = _DBAdapter.GetRelationDeleteSql(t1, t2, conditions, query1);
return(Execute(sql));
}
conditions = conditions.Replace("t1.", "");
return(Delete <T>(conditions));
}
/// <summary>
/// 返回首列结果
/// </summary>
/// <typeparam name="TModel"></typeparam>
/// <param name="iQuery"></param>
/// <returns></returns>
public override dynamic QueryScalar <TModel>(ILambdaQuery <TModel> iQuery)
{
var query = iQuery as LambdaQueryBase;
query.TakeNum = 1;
//using (var reader = GetQueryDynamicReader(query))
//{
// var a = reader.Read();
// if (!a)
// {
// return null;
// }
// var result = reader[0];
// return result;
//}
var list = SqlStopWatch.ReturnData(() =>
{
return(GetQueryDynamicReader(query));
}, (r) =>
{
var reader = r.reader;
var a = reader.Read();
if (!a)
{
return(null);
}
var result = reader[0];
reader.Close();
return(new object[] { result });
});
if (list == null)
{
return(null);
}
return(list.FirstOrDefault());
}
/// <summary>
/// 使用完整的LamadaQuery查询
/// </summary>
/// <typeparam name="TModel"></typeparam>
/// <param name="iQuery"></param>
/// <param name="cacheKey">cacheKey</param>
/// <returns></returns>
public override List <TModel> QueryOrFromCache <TModel>(ILambdaQuery <TModel> iQuery, out string cacheKey)
{
var query = iQuery as LambdaQueryBase;
cacheKey = "";
CheckTableCreated <TModel>();
List <TModel> list = new List <TModel>();
if (query.SkipPage > 0)//按分页
{
list = QueryResult <TModel>(query);
//分页不创建Clone
//if (SettingConfig.AutoTrackingModel && query.__TrackingModel)
//{
// SetOriginClone(list);
//}
return(list);
}
cacheKey = "";
System.Data.Common.DbDataReader reader;
query.FillParames(this);
var sql = query.GetQuery();
sql = _DBAdapter.SqlFormat(sql);
var cacheTime = query.__ExpireMinute;
var compileSp = query.__CompileSp;
double runTime = 0;
var db = GetDBHelper(DataAccessType.Read);
if (cacheTime <= 0)
{
list = SqlStopWatch.ReturnList(() =>
{
if (!compileSp || !_DBAdapter.CanCompileSP)
{
reader = db.ExecDataReader(sql);
}
else//生成储过程
{
string sp = CompileSqlToSp(_DBAdapter.TemplateSp, sql);
reader = db.RunDataReader(sp);
}
query.ExecuteTime += db.ExecuteTime;
var queryInfo = new LambdaQuery.Mapping.QueryInfo <TModel>(false, query.GetQueryFieldString(), query.GetFieldMapping());
return(ObjectConvert.DataReaderToSpecifiedList <TModel>(reader, queryInfo));
}, sql);
query.MapingTime += runTime;
//if(!string.IsNullOrEmpty(query.__RemoveInJionBatchNo))
//{
// Delete<InJoin>(b => b.BatchNo == query.__RemoveInJionBatchNo);
// query.__RemoveInJionBatchNo = "";
//}
}
else
{
list = MemoryDataCache.CacheService.GetCacheList <TModel>(sql, query.GetFieldMapping(), cacheTime, db, out cacheKey).Values.ToList();
}
ClearParame();
query.__RowCount = list.Count;
//query = null;
return(list);
}
public override Dictionary <TKey, TValue> ToDictionary <TModel, TKey, TValue>(ILambdaQuery <TModel> query)
{
var dic = SqlStopWatch.ReturnData(() =>
{
return(GetQueryDynamicReader(query as LambdaQueryBase));
}, (r) =>
{
return(ObjectConvert.DataReadToDictionary <TKey, TValue>(r.reader));
});
return(dic);
}
public override Dictionary <TKey, TValue> ToDictionary <TModel, TKey, TValue>(ILambdaQuery <TModel> query)
{
var dic = new Dictionary <TKey, TValue>();
var result = GetDynamicResult(query);
if (result.Count == 0)
{
return(dic);
}
var first = result.First() as IDictionary <string, object>;
var keys = first.Keys.ToList();
var keyName = keys[0];
var valueName = keys[1];
foreach (var item in result)
{
var obj = item as IDictionary <string, object>;
dic.Add((TKey)obj[keyName], (TValue)obj[valueName]);
}
return(dic);
}
/// <summary> /// 使用完整查询更新 /// </summary> /// <typeparam name="TModel"></typeparam> /// <param name="query"></param> /// <param name="updateValue"></param> /// <returns></returns> public abstract int Update <TModel>(ILambdaQuery <TModel> query, CRL.ParameCollection updateValue) where TModel : class;
/// <summary> /// 按完整查询删除 /// </summary> /// <typeparam name="T"></typeparam> /// <param name="query"></param> /// <returns></returns> public abstract int Delete <T>(ILambdaQuery <T> query) where T : class;
/// <summary> /// 返回首行首列 /// </summary> /// <typeparam name="TModel"></typeparam> /// <param name="query"></param> /// <returns></returns> public abstract dynamic QueryScalar <TModel>(ILambdaQuery <TModel> query) where TModel : class;
/// <summary> /// 返回字典 /// </summary> /// <typeparam name="TModel"></typeparam> /// <typeparam name="TKey"></typeparam> /// <typeparam name="TValue"></typeparam> /// <param name="query"></param> /// <returns></returns> public abstract Dictionary <TKey, TValue> ToDictionary <TModel, TKey, TValue>(ILambdaQuery <TModel> query) where TModel : class;
/// <summary> /// 返回多项结果 /// </summary> /// <typeparam name="TModel"></typeparam> /// <param name="query"></param> /// <param name="cacheKey"></param> /// <returns></returns> public abstract List <TModel> QueryOrFromCache <TModel>(ILambdaQuery <TModel> query, out string cacheKey) where TModel : class;
List <dynamic> GetDynamicResult <TModel>(ILambdaQuery <TModel> iQuery) where TModel : class
{
var query = iQuery as MongoDBLambdaQuery <TModel>;
//var selectField = query.__QueryFields;
var selectField = query.GetFieldMapping();
var collection = GetCollection <TModel>();
var pageIndex = query.SkipPage - 1;
var pageSize = query.TakeNum;
var skip = 0;
long rowNum = 0;
if (query.TakeNum > 0)
{
skip = pageSize * pageIndex;
}
if (query.__GroupFields != null)
{
#region group
var groupInfo = new BsonDocument();
var groupField = new BsonDocument();
foreach (var f in query.__GroupFields)
{
groupField.Add(f.FieldName, "$" + f.FieldName);
}
groupInfo.Add("_id", groupField);
var projection = new BsonDocument();
foreach (var f in selectField)
{
var method = f.MethodName.ToLower();
object sumField = 1;
if (!string.IsNullOrEmpty(method))
{
if (method == "count")
{
groupInfo.Add(f.ResultName, new BsonDocument("$sum", 1));
}
else
{
var memberName = f.QueryField;
memberName = System.Text.RegularExpressions.Regex.Replace(memberName, @"\w+\(+(.+?)\)+", "$1");
#region 字段间运算
string op = "";
string opFunc = "";
if (memberName.Contains("+"))
{
op = "+";
opFunc = "add";
}
else if (memberName.Contains("-"))
{
op = "-";
opFunc = "subtract";
}
else if (memberName.Contains("*"))
{
op = "*";
opFunc = "multiply";
}
else if (memberName.Contains("1"))
{
op = "/";
opFunc = "divide";
}
if (!string.IsNullOrEmpty(op))
{
var arry = memberName.Split(op.First());//仅第一个运算符
//等效 "$sum":{$multiply:["$price","$count"]} sum(price*count)
var bsArry = new BsonArray();
foreach (var field1 in arry)
{
bsArry.Add($"${field1}");
}
var bs1 = new BsonDocument($"${opFunc}", bsArry);
groupInfo.Add(f.ResultName, new BsonDocument("$" + method.ToLower(), bs1));
}
else
{
groupInfo.Add(f.ResultName, new BsonDocument("$" + method.ToLower(), "$" + memberName));
}
#endregion
}
projection.Add(f.ResultName, "$" + f.ResultName);
}
else
{
projection.Add(f.ResultName, "$_id." + f.FieldName);
}
}
var havingExp = query.mongoHavingCount;
var filter = query.__MongoDBFilter;
var aggregate = collection.Aggregate(new AggregateOptions()
{
AllowDiskUse = true
}).Match(filter).Group(groupInfo).Project(projection);
if (havingExp != null)
{
//var filter2 = query.HavingCount(havingExp);
var having = new BsonDocument();
var op = "";
#region op
switch (havingExp.ExpType)
{
case ExpressionType.Equal:
op = "eq";
break;
case ExpressionType.GreaterThan:
op = "gt";
break;
case ExpressionType.GreaterThanOrEqual:
op = "gte";
break;
case ExpressionType.LessThan:
op = "lt";
break;
case ExpressionType.LessThanOrEqual:
op = "lte";
break;
case ExpressionType.NotEqual:
op = "ne";
break;
default:
throw new InvalidCastException("不支持的运算符");
}
#endregion
having.AddRange(new BsonDocument()
.Add(havingExp.Left.Data.ToString(), new BsonDocument()
.Add("$" + op, new BsonInt64(Convert.ToInt64(havingExp.Right.Data)))
));
aggregate = aggregate.Match(having);
}
if (query.TakeNum > 0)
{
if (skip > 0)
{
aggregate = aggregate.Skip(skip);
}
aggregate = aggregate.Limit(pageSize);
//rowNum = collection.Count(query.__MongoDBFilter);//todo 总行数
}
//var str = aggregate.ToString();
query.__QueryReturn = () =>
{
return(aggregate.ToString());
};
var result = aggregate.ToList();
if (rowNum == 0)
{
rowNum = result.Count();
}
var list = new List <dynamic>();
foreach (var item in result)
{
dynamic obj = new System.Dynamic.ExpandoObject();
var dict = obj as IDictionary <string, object>;
foreach (var f in selectField)
{
string columnName = f.ResultName;
object value = BsonTypeMapper.MapToDotNetValue(item[columnName]);
dict.Add(columnName, value);
}
list.Add(obj);
}
return(list);
#endregion
}
else if (query.__DistinctFields)
{
#region distinct
string fieldName = selectField.FirstOrDefault().ResultName;
FieldDefinition <TModel, dynamic> distinctField = fieldName;
var query2 = collection.Distinct(distinctField, query.__MongoDBFilter);
return(query2.ToList());
#endregion
}
else
{
#region 动态类型
var query2 = collection.Find(query.__MongoDBFilter);
if (query.TakeNum > 0)
{
query2.Limit(pageSize);
if (skip > 0)
{
query2.Skip(skip);
}
}
var result = query2.ToList();
var list = new List <dynamic>();
var fields = TypeCache.GetTable(typeof(TModel)).FieldsDic;
foreach (var item in result)
{
dynamic obj = new System.Dynamic.ExpandoObject();
var dict = obj as IDictionary <string, object>;
foreach (var f in selectField)
{
string columnName = f.ResultName;
object value = fields[columnName].GetValue(item);
dict.Add(columnName, value);
}
list.Add(obj);
}
#endregion
return(list);
}
}
