/// <summary>
/// 按类型获取缓存,只能在继承类实现,只能同时有一个类型
/// 不建议直接调用,请调用AllCache或重写调用
/// </summary>
/// <param name="query"></param>
/// <returns></returns>
protected Dictionary <int, TModel> GetCache(LambdaQuery <TModel> query)
{
Type type = typeof(TModel);
int expMinute = query.__ExpireMinute;
if (expMinute == 0)
{
expMinute = 5;
}
query.__ExpireMinute = expMinute;
string dataCacheKey;
var list = new Dictionary <int, TModel>();
if (!TypeCache.ModelKeyCache.ContainsKey(type))
{
var helper = GetDbHelper();//避开事务控制,使用新的连接
var list2 = helper.QueryList <TModel>(query, out dataCacheKey);
list = ObjectConvert.ConvertToDictionary <TModel>(list2);
lock (lockObj)
{
if (!TypeCache.ModelKeyCache.ContainsKey(type))
{
TypeCache.ModelKeyCache.Add(type, dataCacheKey);
}
}
}
else
{
dataCacheKey = TypeCache.ModelKeyCache[type];
list = MemoryDataCache.CacheService.GetCacheItem <TModel>(dataCacheKey);
}
return(list);
}
TType GetFunction <TType, TModel>(Expression <Func <TModel, bool> > expression, Expression <Func <TModel, TType> > selectField, FunctionType functionType, bool compileSp = false) where TModel : IModel, new()
{
LambdaQuery <TModel> query = new LambdaQuery <TModel>(this, false);
string condition = query.FormatExpression(expression);
query.FillParames(this);
string field = "";
if (selectField.Body is MemberExpression)
{
MemberExpression mExp = (MemberExpression)selectField.Body;
field = mExp.Member.Name;
if (!field.Contains(","))
{
field = _DBAdapter.KeyWordFormat(field);
}
}
else
{
var constant = (ConstantExpression)selectField.Body;
field = constant.Value.ToString();
}
CheckTableCreated <TModel>();
string tableName = TypeCache.GetTableName <TModel>();
string sql = "select " + functionType + "(" + field + ") from " + tableName + ' ' + _DBAdapter.GetWithNolockFormat() + " where " + condition;
if (compileSp)
{
return(AutoExecuteScalar <TType>(sql));
}
return(ExecScalar <TType>(sql));
}
/// <summary>
/// 按类型获取缓存,只能在继承类实现,只能同时有一个类型
/// 不建议直接调用,请调用AllCache或重写调用
/// </summary>
/// <param name="query"></param>
/// <returns></returns>
protected Dictionary <string, TModel> GetCache(LambdaQuery <TModel> query)
{
Type type = typeof(TModel);
int expMinute = query.__ExpireMinute;
if (expMinute == 0)
{
expMinute = 5;
}
query.__ExpireMinute = expMinute;
string dataCacheKey;
var list = new Dictionary <string, TModel>();
if (!TypeCache.ModelKeyCache.ContainsKey(type))
{
var db = DBExtend;
var list2 = db.QueryOrFromCache <TModel>(query, out dataCacheKey);
list = ObjectConvert.ConvertToDictionary <TModel>(list2);
lock (lockObj)
{
if (!TypeCache.ModelKeyCache.ContainsKey(type))
{
TypeCache.ModelKeyCache.TryAdd(type, dataCacheKey);
}
}
}
else
{
dataCacheKey = TypeCache.ModelKeyCache[type];
list = MemoryDataCache.CacheService.GetCacheItem <TModel>(dataCacheKey);
}
return(list);
}
//public TType Sum<TType, TModel>(Expression<Func<TModel, bool>> expression, string field, bool compileSp = false) where TModel : IModel, new()
//{
// return GetFunction<TType, TModel>(expression, field, FunctionType.SUM, compileSp);
//}
#endregion
TType GetFunction <TType, TModel>(Expression <Func <TModel, bool> > expression, Expression <Func <TModel, TType> > selectField, FunctionType functionType, bool compileSp = false) where TModel : IModel, new()
{
LambdaQuery <TModel> query = new LambdaQuery <TModel>(dbContext, true);
query.Select(selectField.Body);
query.__FieldFunctionFormat = string.Format("{0}({1}) as Total", functionType, "{0}");
query.Where(expression);
var result = QueryScalar(query);
if (result == null)
{
return(default(TType));
}
return((TType)result);
//string condition = query.FormatExpression(expression);
//query.FillParames(this);
//string field = query.GetQueryFieldString();
//CheckTableCreated<TModel>();
//string tableName = TypeCache.GetTableName(typeof(TModel), dbContext);
//tableName = _DBAdapter.KeyWordFormat(tableName);
//string sql = "select " + functionType + "(" + field + ") from " + tableName + ' ' + _DBAdapter.GetWithNolockFormat() + " where " + condition;
//if (compileSp)
//{
// return AutoExecuteScalar<TType>(sql);
//}
//return ExecScalar<TType>(sql);
}
/// <summary>
/// 返回动态对象的查询
/// 已支持join group
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="query"></param>
/// <param name="cacheTime"></param>
/// <param name="compileSp"></param>
/// <returns></returns>
public List <dynamic> QueryDynamic <T>(LambdaQuery <T> query, int cacheTime = 0, bool compileSp = false)
where T : IModel, new()
{
CheckTableCreated <T>();
string sql = "";
//foreach (var n in query.QueryParames)
//{
// AddParam(n.Key, n.Value);
//}
query.FillParames(this);
sql = query.GetQuery();
sql = _DBAdapter.SqlFormat(sql);
//DataTable dt;
System.Data.Common.DbDataReader reader;
List <dynamic> list;
if (!compileSp)
{
if (query.QueryTop > 0)
{
helper.AutoFormatWithNolock = false;
}
reader = helper.ExecDataReader(sql);
}
else//生成储过程
{
string sp = CompileSqlToSp(_DBAdapter.TemplateSp, sql);
reader = helper.RunDataReader(sql);
}
list = Dynamic.DynamicObjConvert.DataReaderToDynamic(reader);
ClearParame();
return(list);
}
/// <summary>
/// 返回动态类型
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="TResult"></typeparam>
/// <param name="query"></param>
/// <param name="resultSelector"></param>
/// <param name="compileSp"></param>
/// <returns></returns>
public List <TResult> QueryDynamic <T, TResult>(LambdaQuery <T> query, Expression <Func <T, TResult> > resultSelector, bool compileSp = false) where T : IModel, new()
{
CheckTableCreated <T>();
string sql = "";
query.FillParames(this);
sql = query.GetQuery();
sql = _DBAdapter.SqlFormat(sql);
System.Data.Common.DbDataReader reader;
List <TResult> list;
if (!compileSp)
{
if (query.QueryTop > 0)
{
helper.AutoFormatWithNolock = false;
}
reader = helper.ExecDataReader(sql);
}
else//生成储过程
{
string sp = CompileSqlToSp(_DBAdapter.TemplateSp, sql);
reader = helper.RunDataReader(sql);
}
list = Dynamic.DynamicObjConvert.DataReaderToDynamic(reader, resultSelector, query.FieldMapping);
ClearParame();
return(list);
}
/// <summary>
/// GROUP和是否编译判断
/// </summary>
/// <typeparam name="TModel"></typeparam>
/// <param name="query"></param>
/// <returns></returns>
internal CallBackDataReader GetPageReader <TModel>(LambdaQuery <TModel> query) where TModel : IModel, new()
{
if (query.__GroupFields.Count > 0)
{
return(GetGroupPageReader(query));
}
if (_DBAdapter.CanCompileSP && query.__CompileSp)
{
return(GetSpPageReader(query));
}
CheckTableCreated <TModel>();
//var fields = query.GetQueryFieldString(b => b.Length > 500 || b.PropertyType == typeof(byte[]));
var fields = query.GetQueryFieldString();
var rowOver = query.__QueryOrderBy;
if (string.IsNullOrEmpty(rowOver))
{
var table = TypeCache.GetTable(typeof(TModel));
rowOver = string.Format("t1.{0} desc", table.PrimaryKey.Name);
}
var orderBy = System.Text.RegularExpressions.Regex.Replace(rowOver, @"t\d\.", "t.");
var condition = query.GetQueryConditions();
condition = _DBAdapter.SqlFormat(condition);
query.FillParames(this);
var pageIndex = query.__PageIndex;
var pageSize = query.__PageSize;
pageIndex = pageIndex == 0 ? 1 : pageIndex;
pageSize = pageSize == 0 ? 15 : pageSize;
string countSql = string.Format("select count(*) from {0}", condition);
int count = Convert.ToInt32(dbHelper.ExecScalar(countSql));
query.ExecuteTime += dbHelper.ExecuteTime;
query.RowCount = count;
if (count == 0)
{
return(null);
}
int pageCount = (count + pageSize - 1) / pageSize;
if (pageIndex > pageCount)
{
pageIndex = pageCount;
}
var start = pageSize * (pageIndex - 1) + 1;
var end = start + pageSize - 1;
string sql = _DBAdapter.PageSqlFormat(fields, rowOver, condition, start, end, orderBy);
var reader = new CallBackDataReader(dbHelper.ExecDataReader(sql), () =>
{
return(count);
});
query.ExecuteTime += dbHelper.ExecuteTime;
ClearParame();
return(reader);
}
/// <summary>
/// 对GROUP进行分页
/// </summary>
/// <param name="query">包含了group的查询</param>
/// <param name="count"></param>
/// <returns></returns>
public List <dynamic> AutoSpGroupPage(LambdaQuery <TModel> query, out int count)
{
count = 0;
DBExtend helper = dbHelper;
return(helper.AutoSpGroupPage(query, out count));
}
/// <summary>
/// 按类型获取缓存,只能在继承类实现,只能同时有一个类型
/// 不建议直接调用,请调用AllCache或重写调用
/// </summary>
/// <param name="query"></param>
/// <returns></returns>
protected Dictionary <string, TModel> GetCache(LambdaQuery <TModel> query)
{
Type type = typeof(TModel);
int expMinute = query.__ExpireMinute;
if (expMinute == 0)
{
expMinute = 5;
}
query.__ExpireMinute = expMinute;
string dataCacheKey;
var list = new Dictionary <string, TModel>();
var a = TypeCache.GetModelKeyCache(type, DBExtend.DatabaseName, out dataCacheKey);
if (!a)
{
var db = DBExtend;
var list2 = db.QueryOrFromCache <TModel>(query, out dataCacheKey);
list = ObjectConvert.ConvertToDictionary <TModel>(list2);
lock (lockObj)
{
string key2;
a = TypeCache.GetModelKeyCache(type, DBExtend.DatabaseName, out key2);
if (!a)
{
TypeCache.SetModelKeyCache(type, DBExtend.DatabaseName, dataCacheKey);
}
}
}
else
{
list = MemoryDataCache.CacheService.GetCacheItem <TModel>(dataCacheKey);
}
return(list);
}
/// <summary>
/// 按完整查询删除
/// </summary>
/// <param name="query"></param>
/// <returns></returns>
public int Delete(LambdaQuery <TModel> query)
{
AbsDBExtend db = DBExtend;
int n = db.Delete(query);
return(n);
}
/// <summary>
/// 返回动态对象的查询
/// </summary>
/// <typeparam name="TItem"></typeparam>
/// <param name="query"></param>
/// <returns></returns>
internal System.Data.Common.DbDataReader GetQueryDynamicReader <TItem>(LambdaQuery <TItem> query)
where TItem : IModel, new()
{
CheckTableCreated <TItem>();
string sql = "";
query.FillParames(this);
sql = query.GetQuery();
sql = _DBAdapter.SqlFormat(sql);
System.Data.Common.DbDataReader reader;
var compileSp = query.__CompileSp;
if (!compileSp)
{
if (query.__QueryTop > 0)
{
dbHelper.AutoFormatWithNolock = false;
}
reader = dbHelper.ExecDataReader(sql);
}
else//生成储过程
{
string sp = CompileSqlToSp(_DBAdapter.TemplateSp, sql);
reader = dbHelper.RunDataReader(sp);
}
query.ExecuteTime = dbHelper.ExecuteTime;
ClearParame();
return(reader);
}
/// <summary>
/// 创建当前类型查询表达式实列
/// </summary>
/// <returns></returns>
public LambdaQuery <TModel> GetLambdaQuery()
{
var dbContext2 = GetDbContext();//避开事务控制,使用新的连接
var query = new LambdaQuery <TModel>(dbContext2);
return(query);
}
/// <summary>
/// 创建当前类型查询表达式实列
/// </summary>
/// <returns></returns>
public LambdaQuery <TModel> GetLambdaQuery()
{
var helper = GetDbHelper(GetType());//避开事务控制,使用新的连接
var query = new LambdaQuery <TModel>(helper);
return(query);
}
/// <summary>
/// 指定条件删除
/// </summary>
/// <typeparam name="TModel"></typeparam>
/// <param name="expression"></param>
/// <returns></returns>
public int Delete <TModel>(Expression <Func <TModel, bool> > expression) where TModel : IModel, new()
{
LambdaQuery <TModel> query = new LambdaQuery <TModel>(dbContext, false);
string condition = query.FormatExpression(expression);
query.FillParames(this);
return(Delete <TModel>(condition));
}
/// <summary>
/// 使用lamada设置条件查询
/// </summary>
/// <typeparam name="TItem"></typeparam>
/// <param name="expression"></param>
/// <param name="compileSp">是否编译成储过程</param>
/// <returns></returns>
public List <TItem> QueryList <TItem>(Expression <Func <TItem, bool> > expression = null, bool compileSp = false) where TItem : IModel, new()
{
LambdaQuery <TItem> query = new LambdaQuery <TItem>(dbContext);
query.Where(expression);
query.CompileToSp(compileSp);
return(QueryList <TItem>(query));
}
/// <summary>
/// 使用lamada设置条件查询
/// </summary>
/// <typeparam name="TItem"></typeparam>
/// <param name="expression"></param>
/// <param name="compileSp">是否编译成储过程</param>
/// <returns></returns>
public List <TItem> QueryList <TItem>(Expression <Func <TItem, bool> > expression = null, bool compileSp = false) where TItem : IModel, new()
{
LambdaQuery <TItem> query = new LambdaQuery <TItem>(this);
query.Where(expression);
string key;
return(QueryList <TItem>(query, 0, out key, compileSp));
}
/// <summary>
/// 动态对象分页
/// </summary>
/// <typeparam name="TModel"></typeparam>
/// <param name="query"></param>
/// <returns></returns>
public List <dynamic> Page <TModel>(LambdaQuery <TModel> query) where TModel : IModel, new()
{
int count;
var reader = GetPageReader(query);
var list = reader.GetDataDynamic(out count);
query.MapingTime += reader.runTime;
query.RowCount = count;
return(list);
}
/// <summary>
/// 返回动态对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="query"></param>
/// <returns></returns>
public List <dynamic> QueryDynamic <T>(LambdaQuery <T> query)
where T : IModel, new()
{
var reader = GetQueryDynamicReader(query);
double runTime;
var list = Dynamic.DynamicObjConvert.DataReaderToDynamic(reader, out runTime);
query.MapingTime += runTime;
query.RowCount = list.Count;
return(list);
}
/// <summary>
/// 指定对象分页
/// </summary>
/// <typeparam name="TModel"></typeparam>
/// <typeparam name="TResult"></typeparam>
/// <param name="query"></param>
/// <returns></returns>
public List <TResult> Page <TModel, TResult>(LambdaQuery <TModel> query)
where TModel : IModel, new()
where TResult : class, new()
{
int count;
var reader = GetPageReader(query);
var list = reader.GetData <TResult>(out count);
query.MapingTime += reader.runTime;
query.RowCount = count;
return(list);
}
/// <summary>
/// 返回指定类型
/// </summary>
/// <typeparam name="TModel"></typeparam>
/// <typeparam name="TResult"></typeparam>
/// <param name="query"></param>
/// <returns></returns>
public List <TResult> QueryDynamic <TModel, TResult>(LambdaQuery <TModel> query)
where TModel : IModel, new()
where TResult : class, new()
{
var reader = GetQueryDynamicReader(query);
double runTime;
var list = ObjectConvert.DataReaderToList <TResult>(reader, out runTime, false);
query.MapingTime += runTime;
query.RowCount = list.Count;
return(list);
}
/// <summary>
/// 按筛选返回匿名类型
/// </summary>
/// <typeparam name="TModel"></typeparam>
/// <typeparam name="TResult"></typeparam>
/// <param name="query"></param>
/// <param name="resultSelector"></param>
/// <returns></returns>
public List <TResult> QueryDynamic <TModel, TResult>(LambdaQuery <TModel> query, Expression <Func <TModel, TResult> > resultSelector) where TModel : IModel, new()
{
//todo 由于不能自动识别TResult,只能按当前类型筛选
CheckTableCreated <TModel>();
query.Select(resultSelector.Body);
var reader = GetQueryDynamicReader(query);
double runTime;
var list = Dynamic.DynamicObjConvert.DataReaderToDynamic(reader, resultSelector, out runTime);
query.MapingTime += runTime;
query.RowCount = list.Count;
return(list);
}
/// <summary>
/// 使用完整的LamadaQuery查询
/// </summary>
/// <typeparam name="TItem"></typeparam>
/// <param name="query"></param>
/// <param name="cacheTime"></param>
/// <param name="cacheKey">过期时间,分</param>
/// <param name="compileSp">是否编译成储过程</param>
/// <returns></returns>
public List <TItem> QueryList <TItem>(LambdaQuery <TItem> query, int cacheTime, out string cacheKey, bool compileSp = false) where TItem : IModel, new()
{
CheckTableCreated <TItem>();
if (query.PageSize > 0)//按分页
{
cacheKey = "";
int count;
return(AutoSpPage(query, out count));
}
string sql = "";
bool setConstraintObj = true;
cacheKey = "";
//foreach (var n in query.QueryParames)
//{
// AddParam(n.Key, n.Value);
//}
query.FillParames(this);
sql = query.GetQuery();
sql = _DBAdapter.SqlFormat(sql);
//DataTable dt;
System.Data.Common.DbDataReader reader;
List <TItem> list;
if (cacheTime <= 0)
{
if (!compileSp)
{
if (query.QueryTop > 0)
{
helper.AutoFormatWithNolock = false;
}
reader = helper.ExecDataReader(sql);
}
else//生成储过程
{
string sp = CompileSqlToSp(_DBAdapter.TemplateSp, sql);
reader = helper.RunDataReader(sql);
}
list = ObjectConvert.DataReaderToList <TItem>(reader, setConstraintObj, query.FieldMapping);
}
else
{
list = MemoryDataCache.GetCacheList <TItem>(sql, cacheTime, helper, out cacheKey).Values.ToList();
}
ClearParame();
query.RowCount = list.Count;
SetOriginClone(list);
return(list);
}
/// <summary>
/// 返回首列结果
/// </summary>
/// <typeparam name="TModel"></typeparam>
/// <param name="query"></param>
/// <returns></returns>
public dynamic QueryScalar <TModel>(LambdaQuery <TModel> query) where TModel : IModel, new()
{
query.Top(1);
var reader = GetQueryDynamicReader(query);
var a = reader.Read();
if (!a)
{
return(null);
}
var result = reader[0];
reader.Close();
return(result);
}
/// <summary>
/// 查询返回单个结果
/// 如果只查询ID,调用QueryItem(id)
/// </summary>
/// <typeparam name="TItem"></typeparam>
/// <param name="expression"></param>
/// <param name="idDest">是否按主键倒序</param>
/// <param name="compileSp">是否编译成存储过程</param>
/// <returns></returns>
public TItem QueryItem <TItem>(Expression <Func <TItem, bool> > expression, bool idDest = true, bool compileSp = false) where TItem : IModel, new()
{
LambdaQuery <TItem> query = new LambdaQuery <TItem>(this);
query.Top(1);
query.Where(expression);
query.OrderByPrimaryKey(idDest);
List <TItem> list = QueryList <TItem>(query, 0, compileSp);
if (list.Count == 0)
{
return(null);
}
return(list[0]);
}
/// <summary>
/// 使用完整的LamadaQuery查询
/// </summary>
/// <typeparam name="TItem"></typeparam>
/// <param name="query"></param>
/// <param name="cacheKey">cacheKey</param>
/// <returns></returns>
public List <TItem> QueryList <TItem>(LambdaQuery <TItem> query, out string cacheKey) where TItem : IModel, new()
{
CheckTableCreated <TItem>();
if (query.__PageSize > 0)//按分页
{
cacheKey = "";
return(Page <TItem, TItem>(query));
}
string sql = "";
cacheKey = "";
query.FillParames(this);
sql = query.GetQuery();
sql = _DBAdapter.SqlFormat(sql);
System.Data.Common.DbDataReader reader;
var cacheTime = query.__ExpireMinute;
var compileSp = query.__CompileSp;
List <TItem> list;
double runTime;
if (cacheTime <= 0)
{
if (!compileSp)
{
if (query.__QueryTop > 0)
{
dbHelper.AutoFormatWithNolock = false;
}
reader = dbHelper.ExecDataReader(sql);
}
else//生成储过程
{
string sp = CompileSqlToSp(_DBAdapter.TemplateSp, sql);
reader = dbHelper.RunDataReader(sql);
}
query.ExecuteTime += dbHelper.ExecuteTime;
list = ObjectConvert.DataReaderToList <TItem>(reader, out runTime, true);
query.MapingTime += runTime;
}
else
{
list = MemoryDataCache.CacheService.GetCacheList <TItem>(sql, cacheTime, dbHelper, out cacheKey).Values.ToList();
}
ClearParame();
query.RowCount = list.Count;
SetOriginClone(list);
return(list);
}
/// <summary>
/// 按编译
/// </summary>
/// <typeparam name="TModel"></typeparam>
/// <param name="query"></param>
/// <returns></returns>
CallBackDataReader GetSpGroupPageReader <TModel>(LambdaQuery <TModel> query) where TModel : IModel, new()
{
CheckTableCreated <TModel>();
var conditions = query.GetQueryConditions();
var fields = query.GetQueryFieldString();
if (!conditions.Contains("group"))
{
throw new Exception("缺少group语法");
}
var rowOver = query.__QueryOrderBy;
if (string.IsNullOrEmpty(rowOver))
{
throw new Exception("Group分页需指定Group排序字段");
//var table = TypeCache.GetTable(typeof(T));
//rowOver = string.Format("t1.{0} desc", table.PrimaryKey.Name);
}
var sort1 = System.Text.RegularExpressions.Regex.Replace(rowOver, @"t\d\.", "");
conditions = _DBAdapter.SqlFormat(conditions);
query.FillParames(this);
var pageIndex = query.__PageIndex;
var pageSize = query.__PageSize;
pageIndex = pageIndex == 0 ? 1 : pageIndex;
pageSize = pageSize == 0 ? 15 : pageSize;
AddParam("pageIndex", pageIndex);
AddParam("pageSize", pageSize);
dbHelper.AddOutParam("count", -1);
Dictionary <string, string> dic = new Dictionary <string, string>();
dic.Add("fields", fields);
dic.Add("rowOver", rowOver);
//dic.Add("sort", sort1);
string sp = CompileSqlToSp(_DBAdapter.TemplateGroupPage, conditions, dic);
CallBackDataReader reader;
reader = new CallBackDataReader(dbHelper.RunDataReader(sp), () =>
{
return(GetOutParam <int>("count"));
});
query.ExecuteTime += dbHelper.ExecuteTime;
ClearParame();
return(reader);
}
/// <summary>
/// 按编译
/// </summary>
/// <typeparam name="TModel"></typeparam>
/// <param name="query"></param>
/// <returns></returns>
CallBackDataReader GetSpPageReader <TModel>(LambdaQuery <TModel> query) where TModel : IModel, new()
{
CheckTableCreated <TModel>();
//var fields = query.GetQueryFieldString(b => b.Length > 500 || b.PropertyType == typeof(byte[]));
var fields = query.GetQueryFieldString();
var rowOver = query.__QueryOrderBy;
if (string.IsNullOrEmpty(rowOver))
{
var table = TypeCache.GetTable(typeof(TModel));
rowOver = string.Format("t1.{0} desc", table.PrimaryKey.Name);
}
var orderBy = System.Text.RegularExpressions.Regex.Replace(rowOver, @"t\d\.", "t.");
var condition = query.GetQueryConditions();
condition = _DBAdapter.SqlFormat(condition);
query.FillParames(this);
var pageIndex = query.__PageIndex;
var pageSize = query.__PageSize;
pageIndex = pageIndex == 0 ? 1 : pageIndex;
pageSize = pageSize == 0 ? 15 : pageSize;
AddParam("pageIndex", pageIndex);
AddParam("pageSize", pageSize);
AddOutParam("count", -1);
Dictionary <string, string> dic = new Dictionary <string, string>();
dic.Add("fields", fields);
dic.Add("sort", orderBy);
dic.Add("rowOver", rowOver);
//string sql = string.Format("{0} with(nolock) where {1}", tableName, where);
string sp = CompileSqlToSp(_DBAdapter.TemplatePage, condition, dic);
CallBackDataReader reader;
reader = new CallBackDataReader(dbHelper.RunDataReader(sp), () =>
{
return(GetOutParam <int>("count"));
});
ClearParame();
query.ExecuteTime += dbHelper.ExecuteTime;
return(reader);
}
/// <summary>
/// 指定条件和参数进行更新
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="expression">条件</param>
/// <param name="setValue">值</param>
/// <returns></returns>
public int Update <T>(Expression <Func <T, bool> > expression, ParameCollection setValue) where T : IModel, new()
{
if (setValue.Count == 0)
{
throw new Exception("更新时发生错误,参数值为空 ParameCollection setValue");
}
LambdaQuery <T> query = new LambdaQuery <T>(this, false);
string condition = query.FormatExpression(expression);
//foreach (var n in query.QueryParames)
//{
// AddParam(n.Key, n.Value);
//}
query.FillParames(this);
var count = Update <T>(setValue, condition);
UpdateCacheItem <T>(expression, setValue);
//CacheUpdated(typeof(T).Name);
return(count);
}
/// <summary>
/// 按类型获取缓存,只能在继承类实现,只能同时有一个类型
/// 不建议直接调用,请调用AllCache或重写调用
/// </summary>
/// <param name="query"></param>
/// <returns></returns>
protected Dictionary <string, T> GetCache(LambdaQuery <T> query)
{
Type type = typeof(T);
int expMinute = query.__ExpireMinute;
if (expMinute == 0)
{
expMinute = 5;
}
query.__ExpireMinute = expMinute;
string dataCacheKey;
var list = new Dictionary <string, T>();
var db = DBExtend as AbsDBExtend;
var a = TypeCache.GetModelKeyCache(type, db.DatabaseName, out dataCacheKey);
if (!a)
{
var helper = db.dbContext.DBHelper;
foreach (var p in query.QueryParames)
{
helper.AddParam(p.Item1, p.Item2);
}
var sql = query.GetQuery();
list = MemoryDataCache.CacheService.GetCacheList <T>(sql, query.GetFieldMapping(), expMinute, helper, out dataCacheKey);
lock (lockObj)
{
string key2;
a = TypeCache.GetModelKeyCache(type, db.DatabaseName, out key2);
if (!a)
{
TypeCache.SetModelKeyCache(type, db.DatabaseName, dataCacheKey);
}
}
}
else
{
list = MemoryDataCache.CacheService.GetCacheItem <T>(dataCacheKey);
}
return(list);
}
/// <summary>
/// 按完整查询条件更新
/// </summary>
/// <param name="query"></param>
/// <param name="updateValue">要按字段值更新,需加前辍$ 如 c["UserId"] = "$UserId"</param>
/// <returns></returns>
public int Update(LambdaQuery <TModel> query, ParameCollection updateValue)
{
var db = DBExtend;
return(db.Update(query, updateValue));
}
